aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
-rw-r--r--Makefile14
-rw-r--r--src/wld/Makefile8
-rw-r--r--src/wld/buffer.c149
-rw-r--r--src/wld/buffered_surface.c281
-rw-r--r--src/wld/color.c1573
-rw-r--r--src/wld/context.c55
-rw-r--r--src/wld/drm-private.h46
-rw-r--r--src/wld/drm.c108
-rw-r--r--src/wld/drm.h52
-rw-r--r--src/wld/dumb.c272
-rw-r--r--src/wld/font.c271
-rw-r--r--src/wld/intel.c390
-rw-r--r--src/wld/intel/batch.c126
-rw-r--r--src/wld/intel/batch.h88
-rw-r--r--src/wld/intel/blt.h549
-rw-r--r--src/wld/intel/i965_pci_ids.h137
-rw-r--r--src/wld/intel/intel.c358
-rw-r--r--src/wld/intel/mi.h27
-rw-r--r--src/wld/nouveau.c678
-rw-r--r--src/wld/nouveau/g80_2d.xml.h894
-rw-r--r--src/wld/nouveau/g80_defs.xml.h744
-rw-r--r--src/wld/nouveau/nouveau.c619
-rw-r--r--src/wld/nouveau/nv_object.xml.h824
-rw-r--r--src/wld/pixman.c626
-rw-r--r--src/wld/pixman.h44
-rw-r--r--src/wld/renderer.c167
-rw-r--r--src/wld/surface.c48
-rw-r--r--src/wld/wayland-drm.c382
-rw-r--r--src/wld/wayland-private.h60
-rw-r--r--src/wld/wayland-shm.c336
-rw-r--r--src/wld/wayland.c372
-rw-r--r--src/wld/wayland.h84
-rw-r--r--src/wld/wld-private.h243
-rw-r--r--src/wld/wld.h284
34 files changed, 5957 insertions, 4952 deletions
diff --git a/Makefile b/Makefile
index d644db3..2ce652f 100644
--- a/Makefile
+++ b/Makefile
@@ -6,27 +6,21 @@ WLDSRC=$(SRC)/wld
PKGS = fontconfig wayland-client wayland-cursor xkbcommon pixman-1 libdrm
-WTERM_SOURCES = $(wildcard $(WLDSRC)/*.c)
WTERM_SOURCES += $(wildcard $(SRC)/*.c)
-WTERM_HEADERS = $(wildcard $(WLDSRC)/*.h)
WTERM_HEADERS += $(wildcard $(SRC)/*.h)
ifeq ($(ENABLE_INTEL),1)
PKGS += libdrm_intel
-WTERM_SOURCES += $(wildcard $(WLDSRC)/intel/*.c)
-WTERM_HEADERS += $(wildcard $(WLDSRC)/intel/*.h)
CFLAGS += -DWITH_INTEL_DRM
endif
ifeq ($(ENABLE_NOUVEAU),1)
PKGS += libdrm_nouveau
-WTERM_SOURCES += $(wildcard $(WLDSRC)/nouveau/*.c)
-WTERM_HEADERS += $(wildcard $(WLDSRC)/nouveau/*.h)
CFLAGS += -DWITH_NOUVEAU_DRM
endif
CFLAGS += -std=gnu99 -Wall -g -DWITH_WAYLAND_DRM -DWITH_WAYLAND_SHM
CFLAGS += $(shell pkg-config --cflags $(PKGS)) -I include
-LDFLAGS = $(shell pkg-config --libs $(PKGS)) -lm -lutil
+LDFLAGS = $(shell pkg-config --libs $(PKGS)) -lm -lutil -L src/wld -lwld
WAYLAND_HEADERS = $(wildcard include/*.xml)
@@ -39,7 +33,7 @@ OBJECTS = $(SOURCES:.c=.o)
BIN_PREFIX = $(PREFIX)
SHARE_PREFIX = $(PREFIX)
-all: wterm
+all: wld wterm
include/config.h:
cp config.def.h include/config.h
@@ -55,8 +49,12 @@ $(OBJECTS): $(HDRS) include/config.h
wterm: $(OBJECTS)
$(CC) -o wterm $(OBJECTS) $(LDFLAGS)
+wld:
+ make -C src/wld
+
clean:
rm -f $(OBJECTS) $(HDRS) $(WAYLAND_SRC) include/config.h wterm
+ make -C src/wld clean
install-icons:
mkdir -p $(SHARE_PREFIX)/share/icons/hicolor/scalable/apps/
diff --git a/src/wld/Makefile b/src/wld/Makefile
index b5db1c8..f8b6256 100644
--- a/src/wld/Makefile
+++ b/src/wld/Makefile
@@ -2,10 +2,10 @@
include config.mk
-#PREFIX ?= /usr/local
-#LIBDIR ?= $(PREFIX)/lib
-#INCLUDEDIR ?= $(PREFIX)/include
-#PKGCONFIGDIR ?= $(LIBDIR)/pkgconfig
+PREFIX ?= /usr/local
+LIBDIR ?= $(PREFIX)/lib
+INCLUDEDIR ?= $(PREFIX)/include
+PKGCONFIGDIR ?= $(LIBDIR)/pkgconfig
PKG_CONFIG ?= pkg-config
WAYLAND_SCANNER ?= wayland-scanner
diff --git a/src/wld/buffer.c b/src/wld/buffer.c
index e0dfee6..46b1b3b 100644
--- a/src/wld/buffer.c
+++ b/src/wld/buffer.c
@@ -21,104 +21,117 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
-
-void buffer_initialize(struct buffer *buffer,
- const struct wld_buffer_impl *impl, uint32_t width,
- uint32_t height, uint32_t format, uint32_t pitch) {
- *((const struct wld_buffer_impl **)&buffer->base.impl) = impl;
- buffer->base.width = width;
- buffer->base.height = height;
- buffer->base.format = format;
- buffer->base.pitch = pitch;
- buffer->base.map = NULL;
- buffer->references = 1;
- buffer->map_references = 0;
- buffer->exporters = NULL;
- buffer->destructors = NULL;
- pixman_region32_init_rect(&buffer->base.damage, 0, 0, width, height);
+#include "wld-private.h"
+
+void buffer_initialize(struct buffer * buffer,
+ const struct wld_buffer_impl * impl,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ *((const struct wld_buffer_impl **) &buffer->base.impl) = impl;
+ buffer->base.width = width;
+ buffer->base.height = height;
+ buffer->base.format = format;
+ buffer->base.pitch = pitch;
+ buffer->base.map = NULL;
+ buffer->references = 1;
+ buffer->map_references = 0;
+ buffer->exporters = NULL;
+ buffer->destructors = NULL;
+ pixman_region32_init_rect(&buffer->base.damage, 0, 0, width, height);
}
EXPORT
-bool wld_map(struct wld_buffer *base) {
- struct buffer *buffer = (void *)base;
+bool wld_map(struct wld_buffer * base)
+{
+ struct buffer * buffer = (void *) base;
- if (buffer->map_references == 0 && !buffer->base.impl->map(buffer))
- return false;
+ if (buffer->map_references == 0 && !buffer->base.impl->map(buffer))
+ return false;
- ++buffer->map_references;
- return true;
+ ++buffer->map_references;
+ return true;
}
EXPORT
-bool wld_unmap(struct wld_buffer *base) {
- struct buffer *buffer = (void *)base;
-
- if (buffer->map_references == 0 ||
- (buffer->map_references == 1 && !buffer->base.impl->unmap(buffer))) {
- return false;
- }
-
- --buffer->map_references;
- return true;
+bool wld_unmap(struct wld_buffer * base)
+{
+ struct buffer * buffer = (void *) base;
+
+ if (buffer->map_references == 0
+ || (buffer->map_references == 1 && !buffer->base.impl->unmap(buffer)))
+ {
+ return false;
+ }
+
+ --buffer->map_references;
+ return true;
}
EXPORT
-bool wld_export(struct wld_buffer *base, uint32_t type,
- union wld_object *object) {
- struct buffer *buffer = (void *)base;
- struct wld_exporter *exporter;
+bool wld_export(struct wld_buffer * base,
+ uint32_t type, union wld_object * object)
+{
+ struct buffer * buffer = (void *) base;
+ struct wld_exporter * exporter;
+
+ for (exporter = buffer->exporters; exporter; exporter = exporter->next)
+ {
+ if (exporter->export(exporter, &buffer->base, type, object))
+ return true;
+ }
- for (exporter = buffer->exporters; exporter; exporter = exporter->next) {
- if (exporter->export(exporter, &buffer->base, type, object))
- return true;
- }
-
- return false;
+ return false;
}
EXPORT
-void wld_buffer_add_exporter(struct wld_buffer *base,
- struct wld_exporter *exporter) {
- struct buffer *buffer = (void *)base;
+void wld_buffer_add_exporter(struct wld_buffer * base,
+ struct wld_exporter * exporter)
+{
+ struct buffer * buffer = (void *) base;
- exporter->next = buffer->exporters;
- buffer->exporters = exporter;
+ exporter->next = buffer->exporters;
+ buffer->exporters = exporter;
}
EXPORT
-void wld_buffer_add_destructor(struct wld_buffer *base,
- struct wld_destructor *destructor) {
- struct buffer *buffer = (void *)base;
+void wld_buffer_add_destructor(struct wld_buffer * base,
+ struct wld_destructor * destructor)
+{
+ struct buffer * buffer = (void *) base;
- destructor->next = buffer->destructors;
- buffer->destructors = destructor;
+ destructor->next = buffer->destructors;
+ buffer->destructors = destructor;
}
EXPORT
-void wld_buffer_reference(struct wld_buffer *base) {
- struct buffer *buffer = (void *)base;
+void wld_buffer_reference(struct wld_buffer * base)
+{
+ struct buffer * buffer = (void *) base;
- ++buffer->references;
+ ++buffer->references;
}
EXPORT
-void wld_buffer_unreference(struct wld_buffer *base) {
- struct buffer *buffer = (void *)base;
- struct wld_destructor *destructor, *next;
+void wld_buffer_unreference(struct wld_buffer * base)
+{
+ struct buffer * buffer = (void *) base;
+ struct wld_destructor * destructor, * next;
- if (--buffer->references > 0)
- return;
+ if (--buffer->references > 0)
+ return;
- pixman_region32_fini(&buffer->base.damage);
+ pixman_region32_fini(&buffer->base.damage);
- for (destructor = buffer->destructors; destructor; destructor = next) {
- next = destructor->next;
- destructor->destroy(destructor);
- }
+ for (destructor = buffer->destructors; destructor; destructor = next)
+ {
+ next = destructor->next;
+ destructor->destroy(destructor);
+ }
- if (buffer->map_references > 0)
- buffer->base.impl->unmap(buffer);
+ if (buffer->map_references > 0)
+ buffer->base.impl->unmap(buffer);
- buffer->base.impl->destroy(buffer);
+ buffer->base.impl->destroy(buffer);
}
+
diff --git a/src/wld/buffered_surface.c b/src/wld/buffered_surface.c
index 55d8a51..e3d9133 100644
--- a/src/wld/buffered_surface.c
+++ b/src/wld/buffered_surface.c
@@ -21,185 +21,204 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
+#include "wld-private.h"
#include "interface/surface.h"
IMPL(buffered_surface, wld_surface)
-struct buffer_entry {
- struct buffer *buffer;
- bool busy;
+struct buffer_entry
+{
+ struct buffer * buffer;
+ bool busy;
};
-struct buffered_surface {
- struct wld_surface base;
+struct buffered_surface
+{
+ struct wld_surface base;
- struct wld_context *context;
- struct buffer_entry *entries, *back;
- unsigned entries_size, entries_capacity;
+ struct wld_context * context;
+ struct buffer_entry * entries, * back;
+ unsigned entries_size, entries_capacity;
- struct buffer_socket *buffer_socket;
+ struct buffer_socket * buffer_socket;
- uint32_t width, height;
- enum wld_format format;
- uint32_t flags;
+ uint32_t width, height;
+ enum wld_format format;
+ uint32_t flags;
};
-struct wld_surface *
-buffered_surface_create(struct wld_context *context, uint32_t width,
- uint32_t height, uint32_t format, uint32_t flags,
- struct buffer_socket *buffer_socket) {
- struct buffered_surface *surface;
-
- if (!(surface = malloc(sizeof *surface)))
- return NULL;
-
- surface_initialize(&surface->base, &wld_surface_impl);
- surface->context = context;
- surface->entries = NULL;
- surface->back = NULL;
- surface->entries_size = 0;
- surface->entries_capacity = 0;
- surface->buffer_socket = buffer_socket;
- surface->width = width;
- surface->height = height;
- surface->format = format;
- surface->flags = flags;
-
- return &surface->base;
+struct wld_surface * buffered_surface_create
+ (struct wld_context * context, uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags, struct buffer_socket * buffer_socket)
+{
+ struct buffered_surface * surface;
+
+ if (!(surface = malloc(sizeof *surface)))
+ return NULL;
+
+ surface_initialize(&surface->base, &wld_surface_impl);
+ surface->context = context;
+ surface->entries = NULL;
+ surface->back = NULL;
+ surface->entries_size = 0;
+ surface->entries_capacity = 0;
+ surface->buffer_socket = buffer_socket;
+ surface->width = width;
+ surface->height = height;
+ surface->format = format;
+ surface->flags = flags;
+
+ return &surface->base;
}
-pixman_region32_t *surface_damage(struct wld_surface *base,
- pixman_region32_t *new_damage) {
- struct buffered_surface *surface = buffered_surface(base);
- struct buffer *back_buffer;
- unsigned index;
-
- if (pixman_region32_not_empty(new_damage)) {
- for (index = 0; index < surface->entries_size; ++index) {
- pixman_region32_union(&surface->entries[index].buffer->base.damage,
- &surface->entries[index].buffer->base.damage,
- new_damage);
+pixman_region32_t * surface_damage(struct wld_surface * base,
+ pixman_region32_t * new_damage)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ struct buffer * back_buffer;
+ unsigned index;
+
+ if (pixman_region32_not_empty(new_damage))
+ {
+ for (index = 0; index < surface->entries_size; ++index)
+ {
+ pixman_region32_union(&surface->entries[index].buffer->base.damage,
+ &surface->entries[index].buffer->base.damage,
+ new_damage);
+ }
}
- }
- if (!(back_buffer = surface_back(base)))
- return NULL;
+ if (!(back_buffer = surface_back(base)))
+ return NULL;
- return &back_buffer->base.damage;
+ return &back_buffer->base.damage;
}
-struct buffer *surface_back(struct wld_surface *base) {
- struct buffered_surface *surface = buffered_surface(base);
- unsigned index;
-
- if (surface->back)
- return surface->back->buffer;
-
- /* The buffer socket may need to process any incoming buffer releases. */
- if (surface->buffer_socket)
- surface->buffer_socket->impl->process(surface->buffer_socket);
-
- for (index = 0; index < surface->entries_size; ++index) {
- if (!surface->entries[index].busy) {
- surface->back = &surface->entries[index];
- return surface->back->buffer;
+struct buffer * surface_back(struct wld_surface * base)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ unsigned index;
+
+ if (surface->back)
+ return surface->back->buffer;
+
+ /* The buffer socket may need to process any incoming buffer releases. */
+ if (surface->buffer_socket)
+ surface->buffer_socket->impl->process(surface->buffer_socket);
+
+ for (index = 0; index < surface->entries_size; ++index)
+ {
+ if (!surface->entries[index].busy)
+ {
+ surface->back = &surface->entries[index];
+ return surface->back->buffer;
+ }
}
- }
- /* If there are no free buffers, we need to allocate another one. */
- struct buffer *buffer;
+ /* If there are no free buffers, we need to allocate another one. */
+ struct buffer * buffer;
- buffer = surface->context->impl->create_buffer(
- surface->context, surface->width, surface->height, surface->format,
- surface->flags);
+ buffer = surface->context->impl->create_buffer
+ (surface->context, surface->width, surface->height,
+ surface->format, surface->flags);
- if (!buffer)
- goto error0;
+ if (!buffer)
+ goto error0;
- if (surface->entries_size == surface->entries_capacity) {
- struct buffer_entry *new_entries;
- size_t new_capacity = surface->entries_capacity * 2 + 1;
+ if (surface->entries_size == surface->entries_capacity)
+ {
+ struct buffer_entry * new_entries;
+ size_t new_capacity = surface->entries_capacity * 2 + 1;
- new_entries =
- realloc(surface->entries, new_capacity * sizeof surface->entries[0]);
+ new_entries = realloc(surface->entries,
+ new_capacity * sizeof surface->entries[0]);
- if (!new_entries)
- goto error1;
+ if (!new_entries)
+ goto error1;
- surface->entries = new_entries;
- surface->entries_capacity = new_capacity;
- }
+ surface->entries = new_entries;
+ surface->entries_capacity = new_capacity;
+ }
- surface->back = &surface->entries[surface->entries_size++];
- *surface->back = (struct buffer_entry){.buffer = buffer, .busy = false};
+ surface->back = &surface->entries[surface->entries_size++];
+ *surface->back = (struct buffer_entry) {
+ .buffer = buffer,
+ .busy = false
+ };
- return buffer;
+ return buffer;
-error1:
- wld_buffer_unreference(&buffer->base);
-error0:
- return NULL;
+ error1:
+ wld_buffer_unreference(&buffer->base);
+ error0:
+ return NULL;
}
-struct buffer *surface_take(struct wld_surface *base) {
- struct buffered_surface *surface = buffered_surface(base);
- struct buffer *buffer;
+struct buffer * surface_take(struct wld_surface * base)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ struct buffer * buffer;
- if (!(buffer = surface_back(base)))
- return NULL;
+ if (!(buffer = surface_back(base)))
+ return NULL;
- surface->back->busy = true;
- surface->back = NULL;
- pixman_region32_clear(&buffer->base.damage);
+ surface->back->busy = true;
+ surface->back = NULL;
+ pixman_region32_clear(&buffer->base.damage);
- return buffer;
+ return buffer;
}
-bool surface_release(struct wld_surface *base, struct buffer *buffer) {
- struct buffered_surface *surface = buffered_surface(base);
- unsigned index;
-
- for (index = 0; index < surface->entries_size; ++index) {
- if (surface->entries[index].buffer == buffer) {
- surface->entries[index].busy = false;
- return true;
+bool surface_release(struct wld_surface * base, struct buffer * buffer)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ unsigned index;
+
+ for (index = 0; index < surface->entries_size; ++index)
+ {
+ if (surface->entries[index].buffer == buffer)
+ {
+ surface->entries[index].busy = false;
+ return true;
+ }
}
- }
- return false;
+ return false;
}
-bool surface_swap(struct wld_surface *base) {
- struct buffered_surface *surface = buffered_surface(base);
- struct buffer *buffer;
+bool surface_swap(struct wld_surface * base)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ struct buffer * buffer;
- if (!surface->buffer_socket)
- return false;
+ if (!surface->buffer_socket)
+ return false;
- if (!(buffer = surface_back(base)))
- return false;
+ if (!(buffer = surface_back(base)))
+ return false;
- if (!surface->buffer_socket->impl->attach(surface->buffer_socket, buffer))
- return false;
+ if (!surface->buffer_socket->impl->attach(surface->buffer_socket, buffer))
+ return false;
- surface->back->busy = true;
- surface->back = NULL;
- pixman_region32_clear(&buffer->base.damage);
+ surface->back->busy = true;
+ surface->back = NULL;
+ pixman_region32_clear(&buffer->base.damage);
- return true;
+ return true;
}
-void surface_destroy(struct wld_surface *base) {
- struct buffered_surface *surface = buffered_surface(base);
- unsigned index;
+void surface_destroy(struct wld_surface * base)
+{
+ struct buffered_surface * surface = buffered_surface(base);
+ unsigned index;
- if (surface->buffer_socket)
- surface->buffer_socket->impl->destroy(surface->buffer_socket);
+ if (surface->buffer_socket)
+ surface->buffer_socket->impl->destroy(surface->buffer_socket);
- for (index = 0; index < surface->entries_size; ++index)
- wld_buffer_unreference(&surface->entries[index].buffer->base);
+ for (index = 0; index < surface->entries_size; ++index)
+ wld_buffer_unreference(&surface->entries[index].buffer->base);
- free(surface->entries);
- free(surface);
+ free(surface->entries);
+ free(surface);
}
+
diff --git a/src/wld/color.c b/src/wld/color.c
index c9150fa..88e791a 100644
--- a/src/wld/color.c
+++ b/src/wld/color.c
@@ -28,13 +28,13 @@ Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
All Rights Reserved
-Permission to use, copy, modify, and distribute this software and its
-documentation for any purpose and without fee is hereby granted,
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
provided that the above copyright notice appear in all copies and that
-both that copyright notice and this permission notice appear in
+both that copyright notice and this permission notice appear in
supporting documentation, and that the name of Digital not be
used in advertising or publicity pertaining to distribution of the
-software without specific, written prior permission.
+software without specific, written prior permission.
DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
@@ -46,798 +46,805 @@ SOFTWARE.
******************************************************************/
-#include "wld/wld-private.h"
+#include "wld-private.h"
#include <strings.h>
-struct named_color {
- const char *name;
- uint32_t color;
+struct named_color
+{
+ const char * name;
+ uint32_t color;
};
static const struct named_color named_colors[] = {
- {"alice blue", 0xfff0f8ff},
- {"AliceBlue", 0xfff0f8ff},
- {"antique white", 0xfffaebd7},
- {"AntiqueWhite", 0xfffaebd7},
- {"AntiqueWhite1", 0xffffefdb},
- {"AntiqueWhite2", 0xffeedfcc},
- {"AntiqueWhite3", 0xffcdc0b0},
- {"AntiqueWhite4", 0xff8b8378},
- {"aquamarine", 0xff7fffd4},
- {"aquamarine1", 0xff7fffd4},
- {"aquamarine2", 0xff76eec6},
- {"aquamarine3", 0xff66cdaa},
- {"aquamarine4", 0xff458b74},
- {"azure", 0xfff0ffff},
- {"azure1", 0xfff0ffff},
- {"azure2", 0xffe0eeee},
- {"azure3", 0xffc1cdcd},
- {"azure4", 0xff838b8b},
- {"beige", 0xfff5f5dc},
- {"bisque", 0xffffe4c4},
- {"bisque1", 0xffffe4c4},
- {"bisque2", 0xffeed5b7},
- {"bisque3", 0xffcdb79e},
- {"bisque4", 0xff8b7d6b},
- {"black", 0xff000000},
- {"blanched almond", 0xffffebcd},
- {"BlanchedAlmond", 0xffffebcd},
- {"blue", 0xff0000ff},
- {"blue violet", 0xff8a2be2},
- {"blue1", 0xff0000ff},
- {"blue2", 0xff0000ee},
- {"blue3", 0xff0000cd},
- {"blue4", 0xff00008b},
- {"BlueViolet", 0xff8a2be2},
- {"brown", 0xffa52a2a},
- {"brown1", 0xffff4040},
- {"brown2", 0xffee3b3b},
- {"brown3", 0xffcd3333},
- {"brown4", 0xff8b2323},
- {"burlywood", 0xffdeb887},
- {"burlywood1", 0xffffd39b},
- {"burlywood2", 0xffeec591},
- {"burlywood3", 0xffcdaa7d},
- {"burlywood4", 0xff8b7355},
- {"cadet blue", 0xff5f9ea0},
- {"CadetBlue", 0xff5f9ea0},
- {"CadetBlue1", 0xff98f5ff},
- {"CadetBlue2", 0xff8ee5ee},
- {"CadetBlue3", 0xff7ac5cd},
- {"CadetBlue4", 0xff53868b},
- {"chartreuse", 0xff7fff00},
- {"chartreuse1", 0xff7fff00},
- {"chartreuse2", 0xff76ee00},
- {"chartreuse3", 0xff66cd00},
- {"chartreuse4", 0xff458b00},
- {"chocolate", 0xffd2691e},
- {"chocolate1", 0xffff7f24},
- {"chocolate2", 0xffee7621},
- {"chocolate3", 0xffcd661d},
- {"chocolate4", 0xff8b4513},
- {"coral", 0xffff7f50},
- {"coral1", 0xffff7256},
- {"coral2", 0xffee6a50},
- {"coral3", 0xffcd5b45},
- {"coral4", 0xff8b3e2f},
- {"cornflower blue", 0xff6495ed},
- {"CornflowerBlue", 0xff6495ed},
- {"cornsilk", 0xfffff8dc},
- {"cornsilk1", 0xfffff8dc},
- {"cornsilk2", 0xffeee8cd},
- {"cornsilk3", 0xffcdc8b1},
- {"cornsilk4", 0xff8b8878},
- {"cyan", 0xff00ffff},
- {"cyan1", 0xff00ffff},
- {"cyan2", 0xff00eeee},
- {"cyan3", 0xff00cdcd},
- {"cyan4", 0xff008b8b},
- {"dark blue", 0xff00008b},
- {"dark cyan", 0xff008b8b},
- {"dark goldenrod", 0xffb8860b},
- {"dark gray", 0xffa9a9a9},
- {"dark green", 0xff006400},
- {"dark grey", 0xffa9a9a9},
- {"dark khaki", 0xffbdb76b},
- {"dark magenta", 0xff8b008b},
- {"dark olive green", 0xff556b2f},
- {"dark orange", 0xffff8c00},
- {"dark orchid", 0xff9932cc},
- {"dark red", 0xff8b0000},
- {"dark salmon", 0xffe9967a},
- {"dark sea green", 0xff8fbc8f},
- {"dark slate blue", 0xff483d8b},
- {"dark slate gray", 0xff2f4f4f},
- {"dark slate grey", 0xff2f4f4f},
- {"dark turquoise", 0xff00ced1},
- {"dark violet", 0xff9400d3},
- {"DarkBlue", 0xff00008b},
- {"DarkCyan", 0xff008b8b},
- {"DarkGoldenrod", 0xffb8860b},
- {"DarkGoldenrod1", 0xffffb90f},
- {"DarkGoldenrod2", 0xffeead0e},
- {"DarkGoldenrod3", 0xffcd950c},
- {"DarkGoldenrod4", 0xff8b6508},
- {"DarkGray", 0xffa9a9a9},
- {"DarkGreen", 0xff006400},
- {"DarkGrey", 0xffa9a9a9},
- {"DarkKhaki", 0xffbdb76b},
- {"DarkMagenta", 0xff8b008b},
- {"DarkOliveGreen", 0xff556b2f},
- {"DarkOliveGreen1", 0xffcaff70},
- {"DarkOliveGreen2", 0xffbcee68},
- {"DarkOliveGreen3", 0xffa2cd5a},
- {"DarkOliveGreen4", 0xff6e8b3d},
- {"DarkOrange", 0xffff8c00},
- {"DarkOrange1", 0xffff7f00},
- {"DarkOrange2", 0xffee7600},
- {"DarkOrange3", 0xffcd6600},
- {"DarkOrange4", 0xff8b4500},
- {"DarkOrchid", 0xff9932cc},
- {"DarkOrchid1", 0xffbf3eff},
- {"DarkOrchid2", 0xffb23aee},
- {"DarkOrchid3", 0xff9a32cd},
- {"DarkOrchid4", 0xff68228b},
- {"DarkRed", 0xff8b0000},
- {"DarkSalmon", 0xffe9967a},
- {"DarkSeaGreen", 0xff8fbc8f},
- {"DarkSeaGreen1", 0xffc1ffc1},
- {"DarkSeaGreen2", 0xffb4eeb4},
- {"DarkSeaGreen3", 0xff9bcd9b},
- {"DarkSeaGreen4", 0xff698b69},
- {"DarkSlateBlue", 0xff483d8b},
- {"DarkSlateGray", 0xff2f4f4f},
- {"DarkSlateGray1", 0xff97ffff},
- {"DarkSlateGray2", 0xff8deeee},
- {"DarkSlateGray3", 0xff79cdcd},
- {"DarkSlateGray4", 0xff528b8b},
- {"DarkSlateGrey", 0xff2f4f4f},
- {"DarkTurquoise", 0xff00ced1},
- {"DarkViolet", 0xff9400d3},
- {"deep pink", 0xffff1493},
- {"deep sky blue", 0xff00bfff},
- {"DeepPink", 0xffff1493},
- {"DeepPink1", 0xffff1493},
- {"DeepPink2", 0xffee1289},
- {"DeepPink3", 0xffcd1076},
- {"DeepPink4", 0xff8b0a50},
- {"DeepSkyBlue", 0xff00bfff},
- {"DeepSkyBlue1", 0xff00bfff},
- {"DeepSkyBlue2", 0xff00b2ee},
- {"DeepSkyBlue3", 0xff009acd},
- {"DeepSkyBlue4", 0xff00688b},
- {"dim gray", 0xff696969},
- {"dim grey", 0xff696969},
- {"DimGray", 0xff696969},
- {"DimGrey", 0xff696969},
- {"dodger blue", 0xff1e90ff},
- {"DodgerBlue", 0xff1e90ff},
- {"DodgerBlue1", 0xff1e90ff},
- {"DodgerBlue2", 0xff1c86ee},
- {"DodgerBlue3", 0xff1874cd},
- {"DodgerBlue4", 0xff104e8b},
- {"firebrick", 0xffb22222},
- {"firebrick1", 0xffff3030},
- {"firebrick2", 0xffee2c2c},
- {"firebrick3", 0xffcd2626},
- {"firebrick4", 0xff8b1a1a},
- {"floral white", 0xfffffaf0},
- {"FloralWhite", 0xfffffaf0},
- {"forest green", 0xff228b22},
- {"ForestGreen", 0xff228b22},
- {"gainsboro", 0xffdcdcdc},
- {"ghost white", 0xfff8f8ff},
- {"GhostWhite", 0xfff8f8ff},
- {"gold", 0xffffd700},
- {"gold1", 0xffffd700},
- {"gold2", 0xffeec900},
- {"gold3", 0xffcdad00},
- {"gold4", 0xff8b7500},
- {"goldenrod", 0xffdaa520},
- {"goldenrod1", 0xffffc125},
- {"goldenrod2", 0xffeeb422},
- {"goldenrod3", 0xffcd9b1d},
- {"goldenrod4", 0xff8b6914},
- {"gray", 0xffbebebe},
- {"gray0", 0xff000000},
- {"gray1", 0xff030303},
- {"gray10", 0xff1a1a1a},
- {"gray100", 0xffffffff},
- {"gray11", 0xff1c1c1c},
- {"gray12", 0xff1f1f1f},
- {"gray13", 0xff212121},
- {"gray14", 0xff242424},
- {"gray15", 0xff262626},
- {"gray16", 0xff292929},
- {"gray17", 0xff2b2b2b},
- {"gray18", 0xff2e2e2e},
- {"gray19", 0xff303030},
- {"gray2", 0xff050505},
- {"gray20", 0xff333333},
- {"gray21", 0xff363636},
- {"gray22", 0xff383838},
- {"gray23", 0xff3b3b3b},
- {"gray24", 0xff3d3d3d},
- {"gray25", 0xff404040},
- {"gray26", 0xff424242},
- {"gray27", 0xff454545},
- {"gray28", 0xff474747},
- {"gray29", 0xff4a4a4a},
- {"gray3", 0xff080808},
- {"gray30", 0xff4d4d4d},
- {"gray31", 0xff4f4f4f},
- {"gray32", 0xff525252},
- {"gray33", 0xff545454},
- {"gray34", 0xff575757},
- {"gray35", 0xff595959},
- {"gray36", 0xff5c5c5c},
- {"gray37", 0xff5e5e5e},
- {"gray38", 0xff616161},
- {"gray39", 0xff636363},
- {"gray4", 0xff0a0a0a},
- {"gray40", 0xff666666},
- {"gray41", 0xff696969},
- {"gray42", 0xff6b6b6b},
- {"gray43", 0xff6e6e6e},
- {"gray44", 0xff707070},
- {"gray45", 0xff737373},
- {"gray46", 0xff757575},
- {"gray47", 0xff787878},
- {"gray48", 0xff7a7a7a},
- {"gray49", 0xff7d7d7d},
- {"gray5", 0xff0d0d0d},
- {"gray50", 0xff7f7f7f},
- {"gray51", 0xff828282},
- {"gray52", 0xff858585},
- {"gray53", 0xff878787},
- {"gray54", 0xff8a8a8a},
- {"gray55", 0xff8c8c8c},
- {"gray56", 0xff8f8f8f},
- {"gray57", 0xff919191},
- {"gray58", 0xff949494},
- {"gray59", 0xff969696},
- {"gray6", 0xff0f0f0f},
- {"gray60", 0xff999999},
- {"gray61", 0xff9c9c9c},
- {"gray62", 0xff9e9e9e},
- {"gray63", 0xffa1a1a1},
- {"gray64", 0xffa3a3a3},
- {"gray65", 0xffa6a6a6},
- {"gray66", 0xffa8a8a8},
- {"gray67", 0xffababab},
- {"gray68", 0xffadadad},
- {"gray69", 0xffb0b0b0},
- {"gray7", 0xff121212},
- {"gray70", 0xffb3b3b3},
- {"gray71", 0xffb5b5b5},
- {"gray72", 0xffb8b8b8},
- {"gray73", 0xffbababa},
- {"gray74", 0xffbdbdbd},
- {"gray75", 0xffbfbfbf},
- {"gray76", 0xffc2c2c2},
- {"gray77", 0xffc4c4c4},
- {"gray78", 0xffc7c7c7},
- {"gray79", 0xffc9c9c9},
- {"gray8", 0xff141414},
- {"gray80", 0xffcccccc},
- {"gray81", 0xffcfcfcf},
- {"gray82", 0xffd1d1d1},
- {"gray83", 0xffd4d4d4},
- {"gray84", 0xffd6d6d6},
- {"gray85", 0xffd9d9d9},
- {"gray86", 0xffdbdbdb},
- {"gray87", 0xffdedede},
- {"gray88", 0xffe0e0e0},
- {"gray89", 0xffe3e3e3},
- {"gray9", 0xff171717},
- {"gray90", 0xffe5e5e5},
- {"gray91", 0xffe8e8e8},
- {"gray92", 0xffebebeb},
- {"gray93", 0xffededed},
- {"gray94", 0xfff0f0f0},
- {"gray95", 0xfff2f2f2},
- {"gray96", 0xfff5f5f5},
- {"gray97", 0xfff7f7f7},
- {"gray98", 0xfffafafa},
- {"gray99", 0xfffcfcfc},
- {"green", 0xff00ff00},
- {"green yellow", 0xffadff2f},
- {"green1", 0xff00ff00},
- {"green2", 0xff00ee00},
- {"green3", 0xff00cd00},
- {"green4", 0xff008b00},
- {"GreenYellow", 0xffadff2f},
- {"grey", 0xffbebebe},
- {"grey0", 0xff000000},
- {"grey1", 0xff030303},
- {"grey10", 0xff1a1a1a},
- {"grey100", 0xffffffff},
- {"grey11", 0xff1c1c1c},
- {"grey12", 0xff1f1f1f},
- {"grey13", 0xff212121},
- {"grey14", 0xff242424},
- {"grey15", 0xff262626},
- {"grey16", 0xff292929},
- {"grey17", 0xff2b2b2b},
- {"grey18", 0xff2e2e2e},
- {"grey19", 0xff303030},
- {"grey2", 0xff050505},
- {"grey20", 0xff333333},
- {"grey21", 0xff363636},
- {"grey22", 0xff383838},
- {"grey23", 0xff3b3b3b},
- {"grey24", 0xff3d3d3d},
- {"grey25", 0xff404040},
- {"grey26", 0xff424242},
- {"grey27", 0xff454545},
- {"grey28", 0xff474747},
- {"grey29", 0xff4a4a4a},
- {"grey3", 0xff080808},
- {"grey30", 0xff4d4d4d},
- {"grey31", 0xff4f4f4f},
- {"grey32", 0xff525252},
- {"grey33", 0xff545454},
- {"grey34", 0xff575757},
- {"grey35", 0xff595959},
- {"grey36", 0xff5c5c5c},
- {"grey37", 0xff5e5e5e},
- {"grey38", 0xff616161},
- {"grey39", 0xff636363},
- {"grey4", 0xff0a0a0a},
- {"grey40", 0xff666666},
- {"grey41", 0xff696969},
- {"grey42", 0xff6b6b6b},
- {"grey43", 0xff6e6e6e},
- {"grey44", 0xff707070},
- {"grey45", 0xff737373},
- {"grey46", 0xff757575},
- {"grey47", 0xff787878},
- {"grey48", 0xff7a7a7a},
- {"grey49", 0xff7d7d7d},
- {"grey5", 0xff0d0d0d},
- {"grey50", 0xff7f7f7f},
- {"grey51", 0xff828282},
- {"grey52", 0xff858585},
- {"grey53", 0xff878787},
- {"grey54", 0xff8a8a8a},
- {"grey55", 0xff8c8c8c},
- {"grey56", 0xff8f8f8f},
- {"grey57", 0xff919191},
- {"grey58", 0xff949494},
- {"grey59", 0xff969696},
- {"grey6", 0xff0f0f0f},
- {"grey60", 0xff999999},
- {"grey61", 0xff9c9c9c},
- {"grey62", 0xff9e9e9e},
- {"grey63", 0xffa1a1a1},
- {"grey64", 0xffa3a3a3},
- {"grey65", 0xffa6a6a6},
- {"grey66", 0xffa8a8a8},
- {"grey67", 0xffababab},
- {"grey68", 0xffadadad},
- {"grey69", 0xffb0b0b0},
- {"grey7", 0xff121212},
- {"grey70", 0xffb3b3b3},
- {"grey71", 0xffb5b5b5},
- {"grey72", 0xffb8b8b8},
- {"grey73", 0xffbababa},
- {"grey74", 0xffbdbdbd},
- {"grey75", 0xffbfbfbf},
- {"grey76", 0xffc2c2c2},
- {"grey77", 0xffc4c4c4},
- {"grey78", 0xffc7c7c7},
- {"grey79", 0xffc9c9c9},
- {"grey8", 0xff141414},
- {"grey80", 0xffcccccc},
- {"grey81", 0xffcfcfcf},
- {"grey82", 0xffd1d1d1},
- {"grey83", 0xffd4d4d4},
- {"grey84", 0xffd6d6d6},
- {"grey85", 0xffd9d9d9},
- {"grey86", 0xffdbdbdb},
- {"grey87", 0xffdedede},
- {"grey88", 0xffe0e0e0},
- {"grey89", 0xffe3e3e3},
- {"grey9", 0xff171717},
- {"grey90", 0xffe5e5e5},
- {"grey91", 0xffe8e8e8},
- {"grey92", 0xffebebeb},
- {"grey93", 0xffededed},
- {"grey94", 0xfff0f0f0},
- {"grey95", 0xfff2f2f2},
- {"grey96", 0xfff5f5f5},
- {"grey97", 0xfff7f7f7},
- {"grey98", 0xfffafafa},
- {"grey99", 0xfffcfcfc},
- {"honeydew", 0xfff0fff0},
- {"honeydew1", 0xfff0fff0},
- {"honeydew2", 0xffe0eee0},
- {"honeydew3", 0xffc1cdc1},
- {"honeydew4", 0xff838b83},
- {"hot pink", 0xffff69b4},
- {"HotPink", 0xffff69b4},
- {"HotPink1", 0xffff6eb4},
- {"HotPink2", 0xffee6aa7},
- {"HotPink3", 0xffcd6090},
- {"HotPink4", 0xff8b3a62},
- {"indian red", 0xffcd5c5c},
- {"IndianRed", 0xffcd5c5c},
- {"IndianRed1", 0xffff6a6a},
- {"IndianRed2", 0xffee6363},
- {"IndianRed3", 0xffcd5555},
- {"IndianRed4", 0xff8b3a3a},
- {"ivory", 0xfffffff0},
- {"ivory1", 0xfffffff0},
- {"ivory2", 0xffeeeee0},
- {"ivory3", 0xffcdcdc1},
- {"ivory4", 0xff8b8b83},
- {"khaki", 0xfff0e68c},
- {"khaki1", 0xfffff68f},
- {"khaki2", 0xffeee685},
- {"khaki3", 0xffcdc673},
- {"khaki4", 0xff8b864e},
- {"lavender", 0xffe6e6fa},
- {"lavender blush", 0xfffff0f5},
- {"LavenderBlush", 0xfffff0f5},
- {"LavenderBlush1", 0xfffff0f5},
- {"LavenderBlush2", 0xffeee0e5},
- {"LavenderBlush3", 0xffcdc1c5},
- {"LavenderBlush4", 0xff8b8386},
- {"lawn green", 0xff7cfc00},
- {"LawnGreen", 0xff7cfc00},
- {"lemon chiffon", 0xfffffacd},
- {"LemonChiffon", 0xfffffacd},
- {"LemonChiffon1", 0xfffffacd},
- {"LemonChiffon2", 0xffeee9bf},
- {"LemonChiffon3", 0xffcdc9a5},
- {"LemonChiffon4", 0xff8b8970},
- {"light blue", 0xffadd8e6},
- {"light coral", 0xfff08080},
- {"light cyan", 0xffe0ffff},
- {"light goldenrod", 0xffeedd82},
- {"light goldenrod yellow", 0xfffafad2},
- {"light gray", 0xffd3d3d3},
- {"light green", 0xff90ee90},
- {"light grey", 0xffd3d3d3},
- {"light pink", 0xffffb6c1},
- {"light salmon", 0xffffa07a},
- {"light sea green", 0xff20b2aa},
- {"light sky blue", 0xff87cefa},
- {"light slate blue", 0xff8470ff},
- {"light slate gray", 0xff778899},
- {"light slate grey", 0xff778899},
- {"light steel blue", 0xffb0c4de},
- {"light yellow", 0xffffffe0},
- {"LightBlue", 0xffadd8e6},
- {"LightBlue1", 0xffbfefff},
- {"LightBlue2", 0xffb2dfee},
- {"LightBlue3", 0xff9ac0cd},
- {"LightBlue4", 0xff68838b},
- {"LightCoral", 0xfff08080},
- {"LightCyan", 0xffe0ffff},
- {"LightCyan1", 0xffe0ffff},
- {"LightCyan2", 0xffd1eeee},
- {"LightCyan3", 0xffb4cdcd},
- {"LightCyan4", 0xff7a8b8b},
- {"LightGoldenrod", 0xffeedd82},
- {"LightGoldenrod1", 0xffffec8b},
- {"LightGoldenrod2", 0xffeedc82},
- {"LightGoldenrod3", 0xffcdbe70},
- {"LightGoldenrod4", 0xff8b814c},
- {"LightGoldenrodYellow", 0xfffafad2},
- {"LightGray", 0xffd3d3d3},
- {"LightGreen", 0xff90ee90},
- {"LightGrey", 0xffd3d3d3},
- {"LightPink", 0xffffb6c1},
- {"LightPink1", 0xffffaeb9},
- {"LightPink2", 0xffeea2ad},
- {"LightPink3", 0xffcd8c95},
- {"LightPink4", 0xff8b5f65},
- {"LightSalmon", 0xffffa07a},
- {"LightSalmon1", 0xffffa07a},
- {"LightSalmon2", 0xffee9572},
- {"LightSalmon3", 0xffcd8162},
- {"LightSalmon4", 0xff8b5742},
- {"LightSeaGreen", 0xff20b2aa},
- {"LightSkyBlue", 0xff87cefa},
- {"LightSkyBlue1", 0xffb0e2ff},
- {"LightSkyBlue2", 0xffa4d3ee},
- {"LightSkyBlue3", 0xff8db6cd},
- {"LightSkyBlue4", 0xff607b8b},
- {"LightSlateBlue", 0xff8470ff},
- {"LightSlateGray", 0xff778899},
- {"LightSlateGrey", 0xff778899},
- {"LightSteelBlue", 0xffb0c4de},
- {"LightSteelBlue1", 0xffcae1ff},
- {"LightSteelBlue2", 0xffbcd2ee},
- {"LightSteelBlue3", 0xffa2b5cd},
- {"LightSteelBlue4", 0xff6e7b8b},
- {"LightYellow", 0xffffffe0},
- {"LightYellow1", 0xffffffe0},
- {"LightYellow2", 0xffeeeed1},
- {"LightYellow3", 0xffcdcdb4},
- {"LightYellow4", 0xff8b8b7a},
- {"lime green", 0xff32cd32},
- {"LimeGreen", 0xff32cd32},
- {"linen", 0xfffaf0e6},
- {"magenta", 0xffff00ff},
- {"magenta1", 0xffff00ff},
- {"magenta2", 0xffee00ee},
- {"magenta3", 0xffcd00cd},
- {"magenta4", 0xff8b008b},
- {"maroon", 0xffb03060},
- {"maroon1", 0xffff34b3},
- {"maroon2", 0xffee30a7},
- {"maroon3", 0xffcd2990},
- {"maroon4", 0xff8b1c62},
- {"medium aquamarine", 0xff66cdaa},
- {"medium blue", 0xff0000cd},
- {"medium orchid", 0xffba55d3},
- {"medium purple", 0xff9370db},
- {"medium sea green", 0xff3cb371},
- {"medium slate blue", 0xff7b68ee},
- {"medium spring green", 0xff00fa9a},
- {"medium turquoise", 0xff48d1cc},
- {"medium violet red", 0xffc71585},
- {"MediumAquamarine", 0xff66cdaa},
- {"MediumBlue", 0xff0000cd},
- {"MediumOrchid", 0xffba55d3},
- {"MediumOrchid1", 0xffe066ff},
- {"MediumOrchid2", 0xffd15fee},
- {"MediumOrchid3", 0xffb452cd},
- {"MediumOrchid4", 0xff7a378b},
- {"MediumPurple", 0xff9370db},
- {"MediumPurple1", 0xffab82ff},
- {"MediumPurple2", 0xff9f79ee},
- {"MediumPurple3", 0xff8968cd},
- {"MediumPurple4", 0xff5d478b},
- {"MediumSeaGreen", 0xff3cb371},
- {"MediumSlateBlue", 0xff7b68ee},
- {"MediumSpringGreen", 0xff00fa9a},
- {"MediumTurquoise", 0xff48d1cc},
- {"MediumVioletRed", 0xffc71585},
- {"midnight blue", 0xff191970},
- {"MidnightBlue", 0xff191970},
- {"mint cream", 0xfff5fffa},
- {"MintCream", 0xfff5fffa},
- {"misty rose", 0xffffe4e1},
- {"MistyRose", 0xffffe4e1},
- {"MistyRose1", 0xffffe4e1},
- {"MistyRose2", 0xffeed5d2},
- {"MistyRose3", 0xffcdb7b5},
- {"MistyRose4", 0xff8b7d7b},
- {"moccasin", 0xffffe4b5},
- {"navajo white", 0xffffdead},
- {"NavajoWhite", 0xffffdead},
- {"NavajoWhite1", 0xffffdead},
- {"NavajoWhite2", 0xffeecfa1},
- {"NavajoWhite3", 0xffcdb38b},
- {"NavajoWhite4", 0xff8b795e},
- {"navy", 0xff000080},
- {"navy blue", 0xff000080},
- {"NavyBlue", 0xff000080},
- {"old lace", 0xfffdf5e6},
- {"OldLace", 0xfffdf5e6},
- {"olive drab", 0xff6b8e23},
- {"OliveDrab", 0xff6b8e23},
- {"OliveDrab1", 0xffc0ff3e},
- {"OliveDrab2", 0xffb3ee3a},
- {"OliveDrab3", 0xff9acd32},
- {"OliveDrab4", 0xff698b22},
- {"orange", 0xffffa500},
- {"orange red", 0xffff4500},
- {"orange1", 0xffffa500},
- {"orange2", 0xffee9a00},
- {"orange3", 0xffcd8500},
- {"orange4", 0xff8b5a00},
- {"OrangeRed", 0xffff4500},
- {"OrangeRed1", 0xffff4500},
- {"OrangeRed2", 0xffee4000},
- {"OrangeRed3", 0xffcd3700},
- {"OrangeRed4", 0xff8b2500},
- {"orchid", 0xffda70d6},
- {"orchid1", 0xffff83fa},
- {"orchid2", 0xffee7ae9},
- {"orchid3", 0xffcd69c9},
- {"orchid4", 0xff8b4789},
- {"pale goldenrod", 0xffeee8aa},
- {"pale green", 0xff98fb98},
- {"pale turquoise", 0xffafeeee},
- {"pale violet red", 0xffdb7093},
- {"PaleGoldenrod", 0xffeee8aa},
- {"PaleGreen", 0xff98fb98},
- {"PaleGreen1", 0xff9aff9a},
- {"PaleGreen2", 0xff90ee90},
- {"PaleGreen3", 0xff7ccd7c},
- {"PaleGreen4", 0xff548b54},
- {"PaleTurquoise", 0xffafeeee},
- {"PaleTurquoise1", 0xffbbffff},
- {"PaleTurquoise2", 0xffaeeeee},
- {"PaleTurquoise3", 0xff96cdcd},
- {"PaleTurquoise4", 0xff668b8b},
- {"PaleVioletRed", 0xffdb7093},
- {"PaleVioletRed1", 0xffff82ab},
- {"PaleVioletRed2", 0xffee799f},
- {"PaleVioletRed3", 0xffcd6889},
- {"PaleVioletRed4", 0xff8b475d},
- {"papaya whip", 0xffffefd5},
- {"PapayaWhip", 0xffffefd5},
- {"peach puff", 0xffffdab9},
- {"PeachPuff", 0xffffdab9},
- {"PeachPuff1", 0xffffdab9},
- {"PeachPuff2", 0xffeecbad},
- {"PeachPuff3", 0xffcdaf95},
- {"PeachPuff4", 0xff8b7765},
- {"peru", 0xffcd853f},
- {"pink", 0xffffc0cb},
- {"pink1", 0xffffb5c5},
- {"pink2", 0xffeea9b8},
- {"pink3", 0xffcd919e},
- {"pink4", 0xff8b636c},
- {"plum", 0xffdda0dd},
- {"plum1", 0xffffbbff},
- {"plum2", 0xffeeaeee},
- {"plum3", 0xffcd96cd},
- {"plum4", 0xff8b668b},
- {"powder blue", 0xffb0e0e6},
- {"PowderBlue", 0xffb0e0e6},
- {"purple", 0xffa020f0},
- {"purple1", 0xff9b30ff},
- {"purple2", 0xff912cee},
- {"purple3", 0xff7d26cd},
- {"purple4", 0xff551a8b},
- {"red", 0xffff0000},
- {"red1", 0xffff0000},
- {"red2", 0xffee0000},
- {"red3", 0xffcd0000},
- {"red4", 0xff8b0000},
- {"rosy brown", 0xffbc8f8f},
- {"RosyBrown", 0xffbc8f8f},
- {"RosyBrown1", 0xffffc1c1},
- {"RosyBrown2", 0xffeeb4b4},
- {"RosyBrown3", 0xffcd9b9b},
- {"RosyBrown4", 0xff8b6969},
- {"royal blue", 0xff4169e1},
- {"RoyalBlue", 0xff4169e1},
- {"RoyalBlue1", 0xff4876ff},
- {"RoyalBlue2", 0xff436eee},
- {"RoyalBlue3", 0xff3a5fcd},
- {"RoyalBlue4", 0xff27408b},
- {"saddle brown", 0xff8b4513},
- {"SaddleBrown", 0xff8b4513},
- {"salmon", 0xfffa8072},
- {"salmon1", 0xffff8c69},
- {"salmon2", 0xffee8262},
- {"salmon3", 0xffcd7054},
- {"salmon4", 0xff8b4c39},
- {"sandy brown", 0xfff4a460},
- {"SandyBrown", 0xfff4a460},
- {"sea green", 0xff2e8b57},
- {"SeaGreen", 0xff2e8b57},
- {"SeaGreen1", 0xff54ff9f},
- {"SeaGreen2", 0xff4eee94},
- {"SeaGreen3", 0xff43cd80},
- {"SeaGreen4", 0xff2e8b57},
- {"seashell", 0xfffff5ee},
- {"seashell1", 0xfffff5ee},
- {"seashell2", 0xffeee5de},
- {"seashell3", 0xffcdc5bf},
- {"seashell4", 0xff8b8682},
- {"sienna", 0xffa0522d},
- {"sienna1", 0xffff8247},
- {"sienna2", 0xffee7942},
- {"sienna3", 0xffcd6839},
- {"sienna4", 0xff8b4726},
- {"sky blue", 0xff87ceeb},
- {"SkyBlue", 0xff87ceeb},
- {"SkyBlue1", 0xff87ceff},
- {"SkyBlue2", 0xff7ec0ee},
- {"SkyBlue3", 0xff6ca6cd},
- {"SkyBlue4", 0xff4a708b},
- {"slate blue", 0xff6a5acd},
- {"slate gray", 0xff708090},
- {"slate grey", 0xff708090},
- {"SlateBlue", 0xff6a5acd},
- {"SlateBlue1", 0xff836fff},
- {"SlateBlue2", 0xff7a67ee},
- {"SlateBlue3", 0xff6959cd},
- {"SlateBlue4", 0xff473c8b},
- {"SlateGray", 0xff708090},
- {"SlateGray1", 0xffc6e2ff},
- {"SlateGray2", 0xffb9d3ee},
- {"SlateGray3", 0xff9fb6cd},
- {"SlateGray4", 0xff6c7b8b},
- {"SlateGrey", 0xff708090},
- {"snow", 0xfffffafa},
- {"snow1", 0xfffffafa},
- {"snow2", 0xffeee9e9},
- {"snow3", 0xffcdc9c9},
- {"snow4", 0xff8b8989},
- {"spring green", 0xff00ff7f},
- {"SpringGreen", 0xff00ff7f},
- {"SpringGreen1", 0xff00ff7f},
- {"SpringGreen2", 0xff00ee76},
- {"SpringGreen3", 0xff00cd66},
- {"SpringGreen4", 0xff008b45},
- {"steel blue", 0xff4682b4},
- {"SteelBlue", 0xff4682b4},
- {"SteelBlue1", 0xff63b8ff},
- {"SteelBlue2", 0xff5cacee},
- {"SteelBlue3", 0xff4f94cd},
- {"SteelBlue4", 0xff36648b},
- {"tan", 0xffd2b48c},
- {"tan1", 0xffffa54f},
- {"tan2", 0xffee9a49},
- {"tan3", 0xffcd853f},
- {"tan4", 0xff8b5a2b},
- {"thistle", 0xffd8bfd8},
- {"thistle1", 0xffffe1ff},
- {"thistle2", 0xffeed2ee},
- {"thistle3", 0xffcdb5cd},
- {"thistle4", 0xff8b7b8b},
- {"tomato", 0xffff6347},
- {"tomato1", 0xffff6347},
- {"tomato2", 0xffee5c42},
- {"tomato3", 0xffcd4f39},
- {"tomato4", 0xff8b3626},
- {"turquoise", 0xff40e0d0},
- {"turquoise1", 0xff00f5ff},
- {"turquoise2", 0xff00e5ee},
- {"turquoise3", 0xff00c5cd},
- {"turquoise4", 0xff00868b},
- {"violet", 0xffee82ee},
- {"violet red", 0xffd02090},
- {"VioletRed", 0xffd02090},
- {"VioletRed1", 0xffff3e96},
- {"VioletRed2", 0xffee3a8c},
- {"VioletRed3", 0xffcd3278},
- {"VioletRed4", 0xff8b2252},
- {"wheat", 0xfff5deb3},
- {"wheat1", 0xffffe7ba},
- {"wheat2", 0xffeed8ae},
- {"wheat3", 0xffcdba96},
- {"wheat4", 0xff8b7e66},
- {"white", 0xffffffff},
- {"white smoke", 0xfff5f5f5},
- {"WhiteSmoke", 0xfff5f5f5},
- {"yellow", 0xffffff00},
- {"yellow green", 0xff9acd32},
- {"yellow1", 0xffffff00},
- {"yellow2", 0xffeeee00},
- {"yellow3", 0xffcdcd00},
- {"yellow4", 0xff8b8b00},
- {"YellowGreen", 0xff9acd32}};
+ { "alice blue", 0xfff0f8ff },
+ { "AliceBlue", 0xfff0f8ff },
+ { "antique white", 0xfffaebd7 },
+ { "AntiqueWhite", 0xfffaebd7 },
+ { "AntiqueWhite1", 0xffffefdb },
+ { "AntiqueWhite2", 0xffeedfcc },
+ { "AntiqueWhite3", 0xffcdc0b0 },
+ { "AntiqueWhite4", 0xff8b8378 },
+ { "aquamarine", 0xff7fffd4 },
+ { "aquamarine1", 0xff7fffd4 },
+ { "aquamarine2", 0xff76eec6 },
+ { "aquamarine3", 0xff66cdaa },
+ { "aquamarine4", 0xff458b74 },
+ { "azure", 0xfff0ffff },
+ { "azure1", 0xfff0ffff },
+ { "azure2", 0xffe0eeee },
+ { "azure3", 0xffc1cdcd },
+ { "azure4", 0xff838b8b },
+ { "beige", 0xfff5f5dc },
+ { "bisque", 0xffffe4c4 },
+ { "bisque1", 0xffffe4c4 },
+ { "bisque2", 0xffeed5b7 },
+ { "bisque3", 0xffcdb79e },
+ { "bisque4", 0xff8b7d6b },
+ { "black", 0xff000000 },
+ { "blanched almond", 0xffffebcd },
+ { "BlanchedAlmond", 0xffffebcd },
+ { "blue", 0xff0000ff },
+ { "blue violet", 0xff8a2be2 },
+ { "blue1", 0xff0000ff },
+ { "blue2", 0xff0000ee },
+ { "blue3", 0xff0000cd },
+ { "blue4", 0xff00008b },
+ { "BlueViolet", 0xff8a2be2 },
+ { "brown", 0xffa52a2a },
+ { "brown1", 0xffff4040 },
+ { "brown2", 0xffee3b3b },
+ { "brown3", 0xffcd3333 },
+ { "brown4", 0xff8b2323 },
+ { "burlywood", 0xffdeb887 },
+ { "burlywood1", 0xffffd39b },
+ { "burlywood2", 0xffeec591 },
+ { "burlywood3", 0xffcdaa7d },
+ { "burlywood4", 0xff8b7355 },
+ { "cadet blue", 0xff5f9ea0 },
+ { "CadetBlue", 0xff5f9ea0 },
+ { "CadetBlue1", 0xff98f5ff },
+ { "CadetBlue2", 0xff8ee5ee },
+ { "CadetBlue3", 0xff7ac5cd },
+ { "CadetBlue4", 0xff53868b },
+ { "chartreuse", 0xff7fff00 },
+ { "chartreuse1", 0xff7fff00 },
+ { "chartreuse2", 0xff76ee00 },
+ { "chartreuse3", 0xff66cd00 },
+ { "chartreuse4", 0xff458b00 },
+ { "chocolate", 0xffd2691e },
+ { "chocolate1", 0xffff7f24 },
+ { "chocolate2", 0xffee7621 },
+ { "chocolate3", 0xffcd661d },
+ { "chocolate4", 0xff8b4513 },
+ { "coral", 0xffff7f50 },
+ { "coral1", 0xffff7256 },
+ { "coral2", 0xffee6a50 },
+ { "coral3", 0xffcd5b45 },
+ { "coral4", 0xff8b3e2f },
+ { "cornflower blue", 0xff6495ed },
+ { "CornflowerBlue", 0xff6495ed },
+ { "cornsilk", 0xfffff8dc },
+ { "cornsilk1", 0xfffff8dc },
+ { "cornsilk2", 0xffeee8cd },
+ { "cornsilk3", 0xffcdc8b1 },
+ { "cornsilk4", 0xff8b8878 },
+ { "cyan", 0xff00ffff },
+ { "cyan1", 0xff00ffff },
+ { "cyan2", 0xff00eeee },
+ { "cyan3", 0xff00cdcd },
+ { "cyan4", 0xff008b8b },
+ { "dark blue", 0xff00008b },
+ { "dark cyan", 0xff008b8b },
+ { "dark goldenrod", 0xffb8860b },
+ { "dark gray", 0xffa9a9a9 },
+ { "dark green", 0xff006400 },
+ { "dark grey", 0xffa9a9a9 },
+ { "dark khaki", 0xffbdb76b },
+ { "dark magenta", 0xff8b008b },
+ { "dark olive green", 0xff556b2f },
+ { "dark orange", 0xffff8c00 },
+ { "dark orchid", 0xff9932cc },
+ { "dark red", 0xff8b0000 },
+ { "dark salmon", 0xffe9967a },
+ { "dark sea green", 0xff8fbc8f },
+ { "dark slate blue", 0xff483d8b },
+ { "dark slate gray", 0xff2f4f4f },
+ { "dark slate grey", 0xff2f4f4f },
+ { "dark turquoise", 0xff00ced1 },
+ { "dark violet", 0xff9400d3 },
+ { "DarkBlue", 0xff00008b },
+ { "DarkCyan", 0xff008b8b },
+ { "DarkGoldenrod", 0xffb8860b },
+ { "DarkGoldenrod1", 0xffffb90f },
+ { "DarkGoldenrod2", 0xffeead0e },
+ { "DarkGoldenrod3", 0xffcd950c },
+ { "DarkGoldenrod4", 0xff8b6508 },
+ { "DarkGray", 0xffa9a9a9 },
+ { "DarkGreen", 0xff006400 },
+ { "DarkGrey", 0xffa9a9a9 },
+ { "DarkKhaki", 0xffbdb76b },
+ { "DarkMagenta", 0xff8b008b },
+ { "DarkOliveGreen", 0xff556b2f },
+ { "DarkOliveGreen1", 0xffcaff70 },
+ { "DarkOliveGreen2", 0xffbcee68 },
+ { "DarkOliveGreen3", 0xffa2cd5a },
+ { "DarkOliveGreen4", 0xff6e8b3d },
+ { "DarkOrange", 0xffff8c00 },
+ { "DarkOrange1", 0xffff7f00 },
+ { "DarkOrange2", 0xffee7600 },
+ { "DarkOrange3", 0xffcd6600 },
+ { "DarkOrange4", 0xff8b4500 },
+ { "DarkOrchid", 0xff9932cc },
+ { "DarkOrchid1", 0xffbf3eff },
+ { "DarkOrchid2", 0xffb23aee },
+ { "DarkOrchid3", 0xff9a32cd },
+ { "DarkOrchid4", 0xff68228b },
+ { "DarkRed", 0xff8b0000 },
+ { "DarkSalmon", 0xffe9967a },
+ { "DarkSeaGreen", 0xff8fbc8f },
+ { "DarkSeaGreen1", 0xffc1ffc1 },
+ { "DarkSeaGreen2", 0xffb4eeb4 },
+ { "DarkSeaGreen3", 0xff9bcd9b },
+ { "DarkSeaGreen4", 0xff698b69 },
+ { "DarkSlateBlue", 0xff483d8b },
+ { "DarkSlateGray", 0xff2f4f4f },
+ { "DarkSlateGray1", 0xff97ffff },
+ { "DarkSlateGray2", 0xff8deeee },
+ { "DarkSlateGray3", 0xff79cdcd },
+ { "DarkSlateGray4", 0xff528b8b },
+ { "DarkSlateGrey", 0xff2f4f4f },
+ { "DarkTurquoise", 0xff00ced1 },
+ { "DarkViolet", 0xff9400d3 },
+ { "deep pink", 0xffff1493 },
+ { "deep sky blue", 0xff00bfff },
+ { "DeepPink", 0xffff1493 },
+ { "DeepPink1", 0xffff1493 },
+ { "DeepPink2", 0xffee1289 },
+ { "DeepPink3", 0xffcd1076 },
+ { "DeepPink4", 0xff8b0a50 },
+ { "DeepSkyBlue", 0xff00bfff },
+ { "DeepSkyBlue1", 0xff00bfff },
+ { "DeepSkyBlue2", 0xff00b2ee },
+ { "DeepSkyBlue3", 0xff009acd },
+ { "DeepSkyBlue4", 0xff00688b },
+ { "dim gray", 0xff696969 },
+ { "dim grey", 0xff696969 },
+ { "DimGray", 0xff696969 },
+ { "DimGrey", 0xff696969 },
+ { "dodger blue", 0xff1e90ff },
+ { "DodgerBlue", 0xff1e90ff },
+ { "DodgerBlue1", 0xff1e90ff },
+ { "DodgerBlue2", 0xff1c86ee },
+ { "DodgerBlue3", 0xff1874cd },
+ { "DodgerBlue4", 0xff104e8b },
+ { "firebrick", 0xffb22222 },
+ { "firebrick1", 0xffff3030 },
+ { "firebrick2", 0xffee2c2c },
+ { "firebrick3", 0xffcd2626 },
+ { "firebrick4", 0xff8b1a1a },
+ { "floral white", 0xfffffaf0 },
+ { "FloralWhite", 0xfffffaf0 },
+ { "forest green", 0xff228b22 },
+ { "ForestGreen", 0xff228b22 },
+ { "gainsboro", 0xffdcdcdc },
+ { "ghost white", 0xfff8f8ff },
+ { "GhostWhite", 0xfff8f8ff },
+ { "gold", 0xffffd700 },
+ { "gold1", 0xffffd700 },
+ { "gold2", 0xffeec900 },
+ { "gold3", 0xffcdad00 },
+ { "gold4", 0xff8b7500 },
+ { "goldenrod", 0xffdaa520 },
+ { "goldenrod1", 0xffffc125 },
+ { "goldenrod2", 0xffeeb422 },
+ { "goldenrod3", 0xffcd9b1d },
+ { "goldenrod4", 0xff8b6914 },
+ { "gray", 0xffbebebe },
+ { "gray0", 0xff000000 },
+ { "gray1", 0xff030303 },
+ { "gray10", 0xff1a1a1a },
+ { "gray100", 0xffffffff },
+ { "gray11", 0xff1c1c1c },
+ { "gray12", 0xff1f1f1f },
+ { "gray13", 0xff212121 },
+ { "gray14", 0xff242424 },
+ { "gray15", 0xff262626 },
+ { "gray16", 0xff292929 },
+ { "gray17", 0xff2b2b2b },
+ { "gray18", 0xff2e2e2e },
+ { "gray19", 0xff303030 },
+ { "gray2", 0xff050505 },
+ { "gray20", 0xff333333 },
+ { "gray21", 0xff363636 },
+ { "gray22", 0xff383838 },
+ { "gray23", 0xff3b3b3b },
+ { "gray24", 0xff3d3d3d },
+ { "gray25", 0xff404040 },
+ { "gray26", 0xff424242 },
+ { "gray27", 0xff454545 },
+ { "gray28", 0xff474747 },
+ { "gray29", 0xff4a4a4a },
+ { "gray3", 0xff080808 },
+ { "gray30", 0xff4d4d4d },
+ { "gray31", 0xff4f4f4f },
+ { "gray32", 0xff525252 },
+ { "gray33", 0xff545454 },
+ { "gray34", 0xff575757 },
+ { "gray35", 0xff595959 },
+ { "gray36", 0xff5c5c5c },
+ { "gray37", 0xff5e5e5e },
+ { "gray38", 0xff616161 },
+ { "gray39", 0xff636363 },
+ { "gray4", 0xff0a0a0a },
+ { "gray40", 0xff666666 },
+ { "gray41", 0xff696969 },
+ { "gray42", 0xff6b6b6b },
+ { "gray43", 0xff6e6e6e },
+ { "gray44", 0xff707070 },
+ { "gray45", 0xff737373 },
+ { "gray46", 0xff757575 },
+ { "gray47", 0xff787878 },
+ { "gray48", 0xff7a7a7a },
+ { "gray49", 0xff7d7d7d },
+ { "gray5", 0xff0d0d0d },
+ { "gray50", 0xff7f7f7f },
+ { "gray51", 0xff828282 },
+ { "gray52", 0xff858585 },
+ { "gray53", 0xff878787 },
+ { "gray54", 0xff8a8a8a },
+ { "gray55", 0xff8c8c8c },
+ { "gray56", 0xff8f8f8f },
+ { "gray57", 0xff919191 },
+ { "gray58", 0xff949494 },
+ { "gray59", 0xff969696 },
+ { "gray6", 0xff0f0f0f },
+ { "gray60", 0xff999999 },
+ { "gray61", 0xff9c9c9c },
+ { "gray62", 0xff9e9e9e },
+ { "gray63", 0xffa1a1a1 },
+ { "gray64", 0xffa3a3a3 },
+ { "gray65", 0xffa6a6a6 },
+ { "gray66", 0xffa8a8a8 },
+ { "gray67", 0xffababab },
+ { "gray68", 0xffadadad },
+ { "gray69", 0xffb0b0b0 },
+ { "gray7", 0xff121212 },
+ { "gray70", 0xffb3b3b3 },
+ { "gray71", 0xffb5b5b5 },
+ { "gray72", 0xffb8b8b8 },
+ { "gray73", 0xffbababa },
+ { "gray74", 0xffbdbdbd },
+ { "gray75", 0xffbfbfbf },
+ { "gray76", 0xffc2c2c2 },
+ { "gray77", 0xffc4c4c4 },
+ { "gray78", 0xffc7c7c7 },
+ { "gray79", 0xffc9c9c9 },
+ { "gray8", 0xff141414 },
+ { "gray80", 0xffcccccc },
+ { "gray81", 0xffcfcfcf },
+ { "gray82", 0xffd1d1d1 },
+ { "gray83", 0xffd4d4d4 },
+ { "gray84", 0xffd6d6d6 },
+ { "gray85", 0xffd9d9d9 },
+ { "gray86", 0xffdbdbdb },
+ { "gray87", 0xffdedede },
+ { "gray88", 0xffe0e0e0 },
+ { "gray89", 0xffe3e3e3 },
+ { "gray9", 0xff171717 },
+ { "gray90", 0xffe5e5e5 },
+ { "gray91", 0xffe8e8e8 },
+ { "gray92", 0xffebebeb },
+ { "gray93", 0xffededed },
+ { "gray94", 0xfff0f0f0 },
+ { "gray95", 0xfff2f2f2 },
+ { "gray96", 0xfff5f5f5 },
+ { "gray97", 0xfff7f7f7 },
+ { "gray98", 0xfffafafa },
+ { "gray99", 0xfffcfcfc },
+ { "green", 0xff00ff00 },
+ { "green yellow", 0xffadff2f },
+ { "green1", 0xff00ff00 },
+ { "green2", 0xff00ee00 },
+ { "green3", 0xff00cd00 },
+ { "green4", 0xff008b00 },
+ { "GreenYellow", 0xffadff2f },
+ { "grey", 0xffbebebe },
+ { "grey0", 0xff000000 },
+ { "grey1", 0xff030303 },
+ { "grey10", 0xff1a1a1a },
+ { "grey100", 0xffffffff },
+ { "grey11", 0xff1c1c1c },
+ { "grey12", 0xff1f1f1f },
+ { "grey13", 0xff212121 },
+ { "grey14", 0xff242424 },
+ { "grey15", 0xff262626 },
+ { "grey16", 0xff292929 },
+ { "grey17", 0xff2b2b2b },
+ { "grey18", 0xff2e2e2e },
+ { "grey19", 0xff303030 },
+ { "grey2", 0xff050505 },
+ { "grey20", 0xff333333 },
+ { "grey21", 0xff363636 },
+ { "grey22", 0xff383838 },
+ { "grey23", 0xff3b3b3b },
+ { "grey24", 0xff3d3d3d },
+ { "grey25", 0xff404040 },
+ { "grey26", 0xff424242 },
+ { "grey27", 0xff454545 },
+ { "grey28", 0xff474747 },
+ { "grey29", 0xff4a4a4a },
+ { "grey3", 0xff080808 },
+ { "grey30", 0xff4d4d4d },
+ { "grey31", 0xff4f4f4f },
+ { "grey32", 0xff525252 },
+ { "grey33", 0xff545454 },
+ { "grey34", 0xff575757 },
+ { "grey35", 0xff595959 },
+ { "grey36", 0xff5c5c5c },
+ { "grey37", 0xff5e5e5e },
+ { "grey38", 0xff616161 },
+ { "grey39", 0xff636363 },
+ { "grey4", 0xff0a0a0a },
+ { "grey40", 0xff666666 },
+ { "grey41", 0xff696969 },
+ { "grey42", 0xff6b6b6b },
+ { "grey43", 0xff6e6e6e },
+ { "grey44", 0xff707070 },
+ { "grey45", 0xff737373 },
+ { "grey46", 0xff757575 },
+ { "grey47", 0xff787878 },
+ { "grey48", 0xff7a7a7a },
+ { "grey49", 0xff7d7d7d },
+ { "grey5", 0xff0d0d0d },
+ { "grey50", 0xff7f7f7f },
+ { "grey51", 0xff828282 },
+ { "grey52", 0xff858585 },
+ { "grey53", 0xff878787 },
+ { "grey54", 0xff8a8a8a },
+ { "grey55", 0xff8c8c8c },
+ { "grey56", 0xff8f8f8f },
+ { "grey57", 0xff919191 },
+ { "grey58", 0xff949494 },
+ { "grey59", 0xff969696 },
+ { "grey6", 0xff0f0f0f },
+ { "grey60", 0xff999999 },
+ { "grey61", 0xff9c9c9c },
+ { "grey62", 0xff9e9e9e },
+ { "grey63", 0xffa1a1a1 },
+ { "grey64", 0xffa3a3a3 },
+ { "grey65", 0xffa6a6a6 },
+ { "grey66", 0xffa8a8a8 },
+ { "grey67", 0xffababab },
+ { "grey68", 0xffadadad },
+ { "grey69", 0xffb0b0b0 },
+ { "grey7", 0xff121212 },
+ { "grey70", 0xffb3b3b3 },
+ { "grey71", 0xffb5b5b5 },
+ { "grey72", 0xffb8b8b8 },
+ { "grey73", 0xffbababa },
+ { "grey74", 0xffbdbdbd },
+ { "grey75", 0xffbfbfbf },
+ { "grey76", 0xffc2c2c2 },
+ { "grey77", 0xffc4c4c4 },
+ { "grey78", 0xffc7c7c7 },
+ { "grey79", 0xffc9c9c9 },
+ { "grey8", 0xff141414 },
+ { "grey80", 0xffcccccc },
+ { "grey81", 0xffcfcfcf },
+ { "grey82", 0xffd1d1d1 },
+ { "grey83", 0xffd4d4d4 },
+ { "grey84", 0xffd6d6d6 },
+ { "grey85", 0xffd9d9d9 },
+ { "grey86", 0xffdbdbdb },
+ { "grey87", 0xffdedede },
+ { "grey88", 0xffe0e0e0 },
+ { "grey89", 0xffe3e3e3 },
+ { "grey9", 0xff171717 },
+ { "grey90", 0xffe5e5e5 },
+ { "grey91", 0xffe8e8e8 },
+ { "grey92", 0xffebebeb },
+ { "grey93", 0xffededed },
+ { "grey94", 0xfff0f0f0 },
+ { "grey95", 0xfff2f2f2 },
+ { "grey96", 0xfff5f5f5 },
+ { "grey97", 0xfff7f7f7 },
+ { "grey98", 0xfffafafa },
+ { "grey99", 0xfffcfcfc },
+ { "honeydew", 0xfff0fff0 },
+ { "honeydew1", 0xfff0fff0 },
+ { "honeydew2", 0xffe0eee0 },
+ { "honeydew3", 0xffc1cdc1 },
+ { "honeydew4", 0xff838b83 },
+ { "hot pink", 0xffff69b4 },
+ { "HotPink", 0xffff69b4 },
+ { "HotPink1", 0xffff6eb4 },
+ { "HotPink2", 0xffee6aa7 },
+ { "HotPink3", 0xffcd6090 },
+ { "HotPink4", 0xff8b3a62 },
+ { "indian red", 0xffcd5c5c },
+ { "IndianRed", 0xffcd5c5c },
+ { "IndianRed1", 0xffff6a6a },
+ { "IndianRed2", 0xffee6363 },
+ { "IndianRed3", 0xffcd5555 },
+ { "IndianRed4", 0xff8b3a3a },
+ { "ivory", 0xfffffff0 },
+ { "ivory1", 0xfffffff0 },
+ { "ivory2", 0xffeeeee0 },
+ { "ivory3", 0xffcdcdc1 },
+ { "ivory4", 0xff8b8b83 },
+ { "khaki", 0xfff0e68c },
+ { "khaki1", 0xfffff68f },
+ { "khaki2", 0xffeee685 },
+ { "khaki3", 0xffcdc673 },
+ { "khaki4", 0xff8b864e },
+ { "lavender", 0xffe6e6fa },
+ { "lavender blush", 0xfffff0f5 },
+ { "LavenderBlush", 0xfffff0f5 },
+ { "LavenderBlush1", 0xfffff0f5 },
+ { "LavenderBlush2", 0xffeee0e5 },
+ { "LavenderBlush3", 0xffcdc1c5 },
+ { "LavenderBlush4", 0xff8b8386 },
+ { "lawn green", 0xff7cfc00 },
+ { "LawnGreen", 0xff7cfc00 },
+ { "lemon chiffon", 0xfffffacd },
+ { "LemonChiffon", 0xfffffacd },
+ { "LemonChiffon1", 0xfffffacd },
+ { "LemonChiffon2", 0xffeee9bf },
+ { "LemonChiffon3", 0xffcdc9a5 },
+ { "LemonChiffon4", 0xff8b8970 },
+ { "light blue", 0xffadd8e6 },
+ { "light coral", 0xfff08080 },
+ { "light cyan", 0xffe0ffff },
+ { "light goldenrod", 0xffeedd82 },
+ { "light goldenrod yellow", 0xfffafad2 },
+ { "light gray", 0xffd3d3d3 },
+ { "light green", 0xff90ee90 },
+ { "light grey", 0xffd3d3d3 },
+ { "light pink", 0xffffb6c1 },
+ { "light salmon", 0xffffa07a },
+ { "light sea green", 0xff20b2aa },
+ { "light sky blue", 0xff87cefa },
+ { "light slate blue", 0xff8470ff },
+ { "light slate gray", 0xff778899 },
+ { "light slate grey", 0xff778899 },
+ { "light steel blue", 0xffb0c4de },
+ { "light yellow", 0xffffffe0 },
+ { "LightBlue", 0xffadd8e6 },
+ { "LightBlue1", 0xffbfefff },
+ { "LightBlue2", 0xffb2dfee },
+ { "LightBlue3", 0xff9ac0cd },
+ { "LightBlue4", 0xff68838b },
+ { "LightCoral", 0xfff08080 },
+ { "LightCyan", 0xffe0ffff },
+ { "LightCyan1", 0xffe0ffff },
+ { "LightCyan2", 0xffd1eeee },
+ { "LightCyan3", 0xffb4cdcd },
+ { "LightCyan4", 0xff7a8b8b },
+ { "LightGoldenrod", 0xffeedd82 },
+ { "LightGoldenrod1", 0xffffec8b },
+ { "LightGoldenrod2", 0xffeedc82 },
+ { "LightGoldenrod3", 0xffcdbe70 },
+ { "LightGoldenrod4", 0xff8b814c },
+ { "LightGoldenrodYellow", 0xfffafad2 },
+ { "LightGray", 0xffd3d3d3 },
+ { "LightGreen", 0xff90ee90 },
+ { "LightGrey", 0xffd3d3d3 },
+ { "LightPink", 0xffffb6c1 },
+ { "LightPink1", 0xffffaeb9 },
+ { "LightPink2", 0xffeea2ad },
+ { "LightPink3", 0xffcd8c95 },
+ { "LightPink4", 0xff8b5f65 },
+ { "LightSalmon", 0xffffa07a },
+ { "LightSalmon1", 0xffffa07a },
+ { "LightSalmon2", 0xffee9572 },
+ { "LightSalmon3", 0xffcd8162 },
+ { "LightSalmon4", 0xff8b5742 },
+ { "LightSeaGreen", 0xff20b2aa },
+ { "LightSkyBlue", 0xff87cefa },
+ { "LightSkyBlue1", 0xffb0e2ff },
+ { "LightSkyBlue2", 0xffa4d3ee },
+ { "LightSkyBlue3", 0xff8db6cd },
+ { "LightSkyBlue4", 0xff607b8b },
+ { "LightSlateBlue", 0xff8470ff },
+ { "LightSlateGray", 0xff778899 },
+ { "LightSlateGrey", 0xff778899 },
+ { "LightSteelBlue", 0xffb0c4de },
+ { "LightSteelBlue1", 0xffcae1ff },
+ { "LightSteelBlue2", 0xffbcd2ee },
+ { "LightSteelBlue3", 0xffa2b5cd },
+ { "LightSteelBlue4", 0xff6e7b8b },
+ { "LightYellow", 0xffffffe0 },
+ { "LightYellow1", 0xffffffe0 },
+ { "LightYellow2", 0xffeeeed1 },
+ { "LightYellow3", 0xffcdcdb4 },
+ { "LightYellow4", 0xff8b8b7a },
+ { "lime green", 0xff32cd32 },
+ { "LimeGreen", 0xff32cd32 },
+ { "linen", 0xfffaf0e6 },
+ { "magenta", 0xffff00ff },
+ { "magenta1", 0xffff00ff },
+ { "magenta2", 0xffee00ee },
+ { "magenta3", 0xffcd00cd },
+ { "magenta4", 0xff8b008b },
+ { "maroon", 0xffb03060 },
+ { "maroon1", 0xffff34b3 },
+ { "maroon2", 0xffee30a7 },
+ { "maroon3", 0xffcd2990 },
+ { "maroon4", 0xff8b1c62 },
+ { "medium aquamarine", 0xff66cdaa },
+ { "medium blue", 0xff0000cd },
+ { "medium orchid", 0xffba55d3 },
+ { "medium purple", 0xff9370db },
+ { "medium sea green", 0xff3cb371 },
+ { "medium slate blue", 0xff7b68ee },
+ { "medium spring green", 0xff00fa9a },
+ { "medium turquoise", 0xff48d1cc },
+ { "medium violet red", 0xffc71585 },
+ { "MediumAquamarine", 0xff66cdaa },
+ { "MediumBlue", 0xff0000cd },
+ { "MediumOrchid", 0xffba55d3 },
+ { "MediumOrchid1", 0xffe066ff },
+ { "MediumOrchid2", 0xffd15fee },
+ { "MediumOrchid3", 0xffb452cd },
+ { "MediumOrchid4", 0xff7a378b },
+ { "MediumPurple", 0xff9370db },
+ { "MediumPurple1", 0xffab82ff },
+ { "MediumPurple2", 0xff9f79ee },
+ { "MediumPurple3", 0xff8968cd },
+ { "MediumPurple4", 0xff5d478b },
+ { "MediumSeaGreen", 0xff3cb371 },
+ { "MediumSlateBlue", 0xff7b68ee },
+ { "MediumSpringGreen", 0xff00fa9a },
+ { "MediumTurquoise", 0xff48d1cc },
+ { "MediumVioletRed", 0xffc71585 },
+ { "midnight blue", 0xff191970 },
+ { "MidnightBlue", 0xff191970 },
+ { "mint cream", 0xfff5fffa },
+ { "MintCream", 0xfff5fffa },
+ { "misty rose", 0xffffe4e1 },
+ { "MistyRose", 0xffffe4e1 },
+ { "MistyRose1", 0xffffe4e1 },
+ { "MistyRose2", 0xffeed5d2 },
+ { "MistyRose3", 0xffcdb7b5 },
+ { "MistyRose4", 0xff8b7d7b },
+ { "moccasin", 0xffffe4b5 },
+ { "navajo white", 0xffffdead },
+ { "NavajoWhite", 0xffffdead },
+ { "NavajoWhite1", 0xffffdead },
+ { "NavajoWhite2", 0xffeecfa1 },
+ { "NavajoWhite3", 0xffcdb38b },
+ { "NavajoWhite4", 0xff8b795e },
+ { "navy", 0xff000080 },
+ { "navy blue", 0xff000080 },
+ { "NavyBlue", 0xff000080 },
+ { "old lace", 0xfffdf5e6 },
+ { "OldLace", 0xfffdf5e6 },
+ { "olive drab", 0xff6b8e23 },
+ { "OliveDrab", 0xff6b8e23 },
+ { "OliveDrab1", 0xffc0ff3e },
+ { "OliveDrab2", 0xffb3ee3a },
+ { "OliveDrab3", 0xff9acd32 },
+ { "OliveDrab4", 0xff698b22 },
+ { "orange", 0xffffa500 },
+ { "orange red", 0xffff4500 },
+ { "orange1", 0xffffa500 },
+ { "orange2", 0xffee9a00 },
+ { "orange3", 0xffcd8500 },
+ { "orange4", 0xff8b5a00 },
+ { "OrangeRed", 0xffff4500 },
+ { "OrangeRed1", 0xffff4500 },
+ { "OrangeRed2", 0xffee4000 },
+ { "OrangeRed3", 0xffcd3700 },
+ { "OrangeRed4", 0xff8b2500 },
+ { "orchid", 0xffda70d6 },
+ { "orchid1", 0xffff83fa },
+ { "orchid2", 0xffee7ae9 },
+ { "orchid3", 0xffcd69c9 },
+ { "orchid4", 0xff8b4789 },
+ { "pale goldenrod", 0xffeee8aa },
+ { "pale green", 0xff98fb98 },
+ { "pale turquoise", 0xffafeeee },
+ { "pale violet red", 0xffdb7093 },
+ { "PaleGoldenrod", 0xffeee8aa },
+ { "PaleGreen", 0xff98fb98 },
+ { "PaleGreen1", 0xff9aff9a },
+ { "PaleGreen2", 0xff90ee90 },
+ { "PaleGreen3", 0xff7ccd7c },
+ { "PaleGreen4", 0xff548b54 },
+ { "PaleTurquoise", 0xffafeeee },
+ { "PaleTurquoise1", 0xffbbffff },
+ { "PaleTurquoise2", 0xffaeeeee },
+ { "PaleTurquoise3", 0xff96cdcd },
+ { "PaleTurquoise4", 0xff668b8b },
+ { "PaleVioletRed", 0xffdb7093 },
+ { "PaleVioletRed1", 0xffff82ab },
+ { "PaleVioletRed2", 0xffee799f },
+ { "PaleVioletRed3", 0xffcd6889 },
+ { "PaleVioletRed4", 0xff8b475d },
+ { "papaya whip", 0xffffefd5 },
+ { "PapayaWhip", 0xffffefd5 },
+ { "peach puff", 0xffffdab9 },
+ { "PeachPuff", 0xffffdab9 },
+ { "PeachPuff1", 0xffffdab9 },
+ { "PeachPuff2", 0xffeecbad },
+ { "PeachPuff3", 0xffcdaf95 },
+ { "PeachPuff4", 0xff8b7765 },
+ { "peru", 0xffcd853f },
+ { "pink", 0xffffc0cb },
+ { "pink1", 0xffffb5c5 },
+ { "pink2", 0xffeea9b8 },
+ { "pink3", 0xffcd919e },
+ { "pink4", 0xff8b636c },
+ { "plum", 0xffdda0dd },
+ { "plum1", 0xffffbbff },
+ { "plum2", 0xffeeaeee },
+ { "plum3", 0xffcd96cd },
+ { "plum4", 0xff8b668b },
+ { "powder blue", 0xffb0e0e6 },
+ { "PowderBlue", 0xffb0e0e6 },
+ { "purple", 0xffa020f0 },
+ { "purple1", 0xff9b30ff },
+ { "purple2", 0xff912cee },
+ { "purple3", 0xff7d26cd },
+ { "purple4", 0xff551a8b },
+ { "red", 0xffff0000 },
+ { "red1", 0xffff0000 },
+ { "red2", 0xffee0000 },
+ { "red3", 0xffcd0000 },
+ { "red4", 0xff8b0000 },
+ { "rosy brown", 0xffbc8f8f },
+ { "RosyBrown", 0xffbc8f8f },
+ { "RosyBrown1", 0xffffc1c1 },
+ { "RosyBrown2", 0xffeeb4b4 },
+ { "RosyBrown3", 0xffcd9b9b },
+ { "RosyBrown4", 0xff8b6969 },
+ { "royal blue", 0xff4169e1 },
+ { "RoyalBlue", 0xff4169e1 },
+ { "RoyalBlue1", 0xff4876ff },
+ { "RoyalBlue2", 0xff436eee },
+ { "RoyalBlue3", 0xff3a5fcd },
+ { "RoyalBlue4", 0xff27408b },
+ { "saddle brown", 0xff8b4513 },
+ { "SaddleBrown", 0xff8b4513 },
+ { "salmon", 0xfffa8072 },
+ { "salmon1", 0xffff8c69 },
+ { "salmon2", 0xffee8262 },
+ { "salmon3", 0xffcd7054 },
+ { "salmon4", 0xff8b4c39 },
+ { "sandy brown", 0xfff4a460 },
+ { "SandyBrown", 0xfff4a460 },
+ { "sea green", 0xff2e8b57 },
+ { "SeaGreen", 0xff2e8b57 },
+ { "SeaGreen1", 0xff54ff9f },
+ { "SeaGreen2", 0xff4eee94 },
+ { "SeaGreen3", 0xff43cd80 },
+ { "SeaGreen4", 0xff2e8b57 },
+ { "seashell", 0xfffff5ee },
+ { "seashell1", 0xfffff5ee },
+ { "seashell2", 0xffeee5de },
+ { "seashell3", 0xffcdc5bf },
+ { "seashell4", 0xff8b8682 },
+ { "sienna", 0xffa0522d },
+ { "sienna1", 0xffff8247 },
+ { "sienna2", 0xffee7942 },
+ { "sienna3", 0xffcd6839 },
+ { "sienna4", 0xff8b4726 },
+ { "sky blue", 0xff87ceeb },
+ { "SkyBlue", 0xff87ceeb },
+ { "SkyBlue1", 0xff87ceff },
+ { "SkyBlue2", 0xff7ec0ee },
+ { "SkyBlue3", 0xff6ca6cd },
+ { "SkyBlue4", 0xff4a708b },
+ { "slate blue", 0xff6a5acd },
+ { "slate gray", 0xff708090 },
+ { "slate grey", 0xff708090 },
+ { "SlateBlue", 0xff6a5acd },
+ { "SlateBlue1", 0xff836fff },
+ { "SlateBlue2", 0xff7a67ee },
+ { "SlateBlue3", 0xff6959cd },
+ { "SlateBlue4", 0xff473c8b },
+ { "SlateGray", 0xff708090 },
+ { "SlateGray1", 0xffc6e2ff },
+ { "SlateGray2", 0xffb9d3ee },
+ { "SlateGray3", 0xff9fb6cd },
+ { "SlateGray4", 0xff6c7b8b },
+ { "SlateGrey", 0xff708090 },
+ { "snow", 0xfffffafa },
+ { "snow1", 0xfffffafa },
+ { "snow2", 0xffeee9e9 },
+ { "snow3", 0xffcdc9c9 },
+ { "snow4", 0xff8b8989 },
+ { "spring green", 0xff00ff7f },
+ { "SpringGreen", 0xff00ff7f },
+ { "SpringGreen1", 0xff00ff7f },
+ { "SpringGreen2", 0xff00ee76 },
+ { "SpringGreen3", 0xff00cd66 },
+ { "SpringGreen4", 0xff008b45 },
+ { "steel blue", 0xff4682b4 },
+ { "SteelBlue", 0xff4682b4 },
+ { "SteelBlue1", 0xff63b8ff },
+ { "SteelBlue2", 0xff5cacee },
+ { "SteelBlue3", 0xff4f94cd },
+ { "SteelBlue4", 0xff36648b },
+ { "tan", 0xffd2b48c },
+ { "tan1", 0xffffa54f },
+ { "tan2", 0xffee9a49 },
+ { "tan3", 0xffcd853f },
+ { "tan4", 0xff8b5a2b },
+ { "thistle", 0xffd8bfd8 },
+ { "thistle1", 0xffffe1ff },
+ { "thistle2", 0xffeed2ee },
+ { "thistle3", 0xffcdb5cd },
+ { "thistle4", 0xff8b7b8b },
+ { "tomato", 0xffff6347 },
+ { "tomato1", 0xffff6347 },
+ { "tomato2", 0xffee5c42 },
+ { "tomato3", 0xffcd4f39 },
+ { "tomato4", 0xff8b3626 },
+ { "turquoise", 0xff40e0d0 },
+ { "turquoise1", 0xff00f5ff },
+ { "turquoise2", 0xff00e5ee },
+ { "turquoise3", 0xff00c5cd },
+ { "turquoise4", 0xff00868b },
+ { "violet", 0xffee82ee },
+ { "violet red", 0xffd02090 },
+ { "VioletRed", 0xffd02090 },
+ { "VioletRed1", 0xffff3e96 },
+ { "VioletRed2", 0xffee3a8c },
+ { "VioletRed3", 0xffcd3278 },
+ { "VioletRed4", 0xff8b2252 },
+ { "wheat", 0xfff5deb3 },
+ { "wheat1", 0xffffe7ba },
+ { "wheat2", 0xffeed8ae },
+ { "wheat3", 0xffcdba96 },
+ { "wheat4", 0xff8b7e66 },
+ { "white", 0xffffffff },
+ { "white smoke", 0xfff5f5f5 },
+ { "WhiteSmoke", 0xfff5f5f5 },
+ { "yellow", 0xffffff00 },
+ { "yellow green", 0xff9acd32 },
+ { "yellow1", 0xffffff00 },
+ { "yellow2", 0xffeeee00 },
+ { "yellow3", 0xffcdcd00 },
+ { "yellow4", 0xff8b8b00 },
+ { "YellowGreen", 0xff9acd32 }
+};
EXPORT
-bool wld_lookup_named_color(const char *name, uint32_t *color) {
- char *end;
- int low = 0, mid, high = ARRAY_LENGTH(named_colors);
- int r;
+bool wld_lookup_named_color(const char * name, uint32_t * color)
+{
+ char * end;
+ int low = 0, mid, high = ARRAY_LENGTH(named_colors);
+ int r;
- if (name[0] == '#' && name[1] != '\0') {
- *color = strtoul(name + 1, &end, 16);
+ if (name[0] == '#' && name[1] != '\0')
+ {
+ *color = strtoul(name + 1, &end, 16);
- /* Set alpha channel to opaque. */
- *color |= 0xff << 24;
+ /* Set alpha channel to opaque. */
+ *color |= 0xff << 24;
- if (*end == '\0')
- return true;
- }
+ if (*end == '\0')
+ return true;
+ }
- while (low <= high) {
- mid = (low + high) / 2;
- r = strcasecmp(named_colors[mid].name, name);
+ while (low <= high)
+ {
+ mid = (low + high) / 2;
+ r = strcasecmp(named_colors[mid].name, name);
- if (r == 0) {
- *color = named_colors[mid].color;
- return true;
+ if (r == 0)
+ {
+ *color = named_colors[mid].color;
+ return true;
+ }
+ if (r < 0)
+ low = mid + 1;
+ else
+ high = mid - 1;
}
- if (r < 0)
- low = mid + 1;
- else
- high = mid - 1;
- }
- return false;
+ return false;
}
+
diff --git a/src/wld/context.c b/src/wld/context.c
index 73cf4a0..a735d40 100644
--- a/src/wld/context.c
+++ b/src/wld/context.c
@@ -21,45 +21,50 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
+#include "wld-private.h"
-void context_initialize(struct wld_context *context,
- const struct wld_context_impl *impl) {
- *((const struct wld_context_impl **)&context->impl) = impl;
+void context_initialize(struct wld_context * context,
+ const struct wld_context_impl * impl)
+{
+ *((const struct wld_context_impl **) &context->impl) = impl;
}
EXPORT
-struct wld_renderer *wld_create_renderer(struct wld_context *context) {
- return context->impl->create_renderer(context);
+struct wld_renderer * wld_create_renderer(struct wld_context * context)
+{
+ return context->impl->create_renderer(context);
}
EXPORT
-struct wld_buffer *wld_create_buffer(struct wld_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t flags) {
- return &context->impl->create_buffer(context, width, height, format, flags)
- ->base;
+struct wld_buffer * wld_create_buffer(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ return &context->impl->create_buffer(context, width, height,
+ format, flags)->base;
}
EXPORT
-struct wld_buffer *wld_import_buffer(struct wld_context *context, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- return &context->impl
- ->import_buffer(context, type, object, width, height, format,
- pitch)
- ->base;
+struct wld_buffer * wld_import_buffer(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ return &context->impl->import_buffer(context, type, object,
+ width, height, format, pitch)->base;
}
EXPORT
-struct wld_surface *wld_create_surface(struct wld_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t flags) {
- return context->impl->create_surface(context, width, height, format, flags);
+struct wld_surface * wld_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ return context->impl->create_surface(context, width, height, format, flags);
}
EXPORT
-void wld_destroy_context(struct wld_context *context) {
- context->impl->destroy(context);
+void wld_destroy_context(struct wld_context * context)
+{
+ context->impl->destroy(context);
}
+
diff --git a/src/wld/drm-private.h b/src/wld/drm-private.h
new file mode 100644
index 0000000..6c36088
--- /dev/null
+++ b/src/wld/drm-private.h
@@ -0,0 +1,46 @@
+/* wld: drm-private.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_DRM_PRIVATE_H
+#define WLD_DRM_PRIVATE_H
+
+#include "wld-private.h"
+
+struct drm_driver
+{
+ const char * name;
+ bool (* device_supported)(uint32_t vendor_id, uint32_t device_id);
+ struct wld_context * (* create_context)(int drm_fd);
+};
+
+#if WITH_DRM_INTEL
+extern const struct drm_driver intel_drm_driver;
+#endif
+#if WITH_DRM_NOUVEAU
+extern const struct drm_driver nouveau_drm_driver;
+#endif
+extern const struct drm_driver dumb_drm_driver;
+extern const struct wld_context_impl * dumb_context_impl;
+
+#endif
+
diff --git a/src/wld/drm.c b/src/wld/drm.c
index f26fa0b..266f1ac 100644
--- a/src/wld/drm.c
+++ b/src/wld/drm.c
@@ -21,71 +21,87 @@
* SOFTWARE.
*/
-#include "wld/drm.h"
-#include "wld/drm-private.h"
+#include "drm.h"
+#include "drm-private.h"
#include <sys/sysmacros.h>
-const static struct drm_driver *drivers[] = {
+const static struct drm_driver * drivers[] = {
#if WITH_DRM_INTEL
&intel_drm_driver,
#endif
#if WITH_DRM_NOUVEAU
&nouveau_drm_driver,
#endif
- &dumb_drm_driver};
+ &dumb_drm_driver
+};
+
+static const struct drm_driver * find_driver(int fd)
+{
+ char path[64], id[32];
+ uint32_t vendor_id, device_id;
+ char * path_part;
+ struct stat st;
+ FILE * file;
+ uint32_t index;
+ int n;
+
+ if (fstat(fd, &st) == -1)
+ return NULL;
+
+ if (getenv("WLD_DRM_DUMB"))
+ goto dumb;
+
+ n = snprintf(path, sizeof(path), "/sys/dev/char/%u:%u/device/", major(st.st_rdev), minor(st.st_rdev));
+ if (n + 6 >= sizeof(path))
+ return NULL;
+ path_part = path + n;
+
+ strcpy(path_part, "vendor");
+ file = fopen(path, "r");
+ if (!file)
+ goto dumb;
+ fgets(id, sizeof id, file);
+ fclose(file);
+ vendor_id = strtoul(id, NULL, 0);
+
+ strcpy(path_part, "device");
+ file = fopen(path, "r");
+ if (!file)
+ goto dumb;
+ fgets(id, sizeof id, file);
+ fclose(file);
+ device_id = strtoul(id, NULL, 0);
+
+ for (index = 0; index < ARRAY_LENGTH(drivers); ++index)
+ {
+ DEBUG("Trying DRM driver `%s'\n", drivers[index]->name);
+ if (drivers[index]->device_supported(vendor_id, device_id))
+ return drivers[index];
+ }
+
+ DEBUG("No DRM driver supports device 0x%x:0x%x\n", vendor_id, device_id);
-static const struct drm_driver *find_driver(int fd) {
- char path[64], id[32];
- uint32_t vendor_id, device_id;
- char *path_part;
- struct stat st;
- FILE *file;
- uint32_t index;
-
- if (fstat(fd, &st) == -1)
return NULL;
- path_part = path + snprintf(path, sizeof path, "/sys/dev/char/%u:%u/device/",
- major(st.st_rdev), minor(st.st_rdev));
-
- strcpy(path_part, "vendor");
- file = fopen(path, "r");
- fgets(id, sizeof id, file);
- fclose(file);
- vendor_id = strtoul(id, NULL, 0);
-
- strcpy(path_part, "device");
- file = fopen(path, "r");
- fgets(id, sizeof id, file);
- fclose(file);
- device_id = strtoul(id, NULL, 0);
-
- if (getenv("WLD_DRM_DUMB"))
+dumb:
return &dumb_drm_driver;
-
- for (index = 0; index < ARRAY_LENGTH(drivers); ++index) {
- DEBUG("Trying DRM driver `%s'\n", drivers[index]->name);
- if (drivers[index]->device_supported(vendor_id, device_id))
- return drivers[index];
- }
-
- DEBUG("No DRM driver supports device 0x%x:0x%x\n", vendor_id, device_id);
-
- return NULL;
}
EXPORT
-struct wld_context *wld_drm_create_context(int fd) {
- const struct drm_driver *driver;
+struct wld_context * wld_drm_create_context(int fd)
+{
+ const struct drm_driver * driver;
- if (!(driver = find_driver(fd)))
- return NULL;
+ if (!(driver = find_driver(fd)))
+ return NULL;
- return driver->create_context(fd);
+ return driver->create_context(fd);
}
EXPORT
-bool wld_drm_is_dumb(struct wld_context *context) {
- return context->impl == dumb_context_impl;
+bool wld_drm_is_dumb(struct wld_context * context)
+{
+ return context->impl == dumb_context_impl;
}
+
diff --git a/src/wld/drm.h b/src/wld/drm.h
new file mode 100644
index 0000000..20ee3e8
--- /dev/null
+++ b/src/wld/drm.h
@@ -0,0 +1,52 @@
+/* wld: drm.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_DRM_H
+#define WLD_DRM_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+#define WLD_DRM_ID (0x02 << 24)
+
+enum wld_drm_object_type
+{
+ WLD_DRM_OBJECT_HANDLE = WLD_DRM_ID,
+ WLD_DRM_OBJECT_PRIME_FD,
+};
+
+enum wld_drm_flags
+{
+ WLD_DRM_FLAG_SCANOUT = 0x1,
+ WLD_DRM_FLAG_TILED = 0x2
+};
+
+/**
+ * Create a new WLD context from an opened DRM device file descriptor.
+ */
+struct wld_context * wld_drm_create_context(int fd);
+
+bool wld_drm_is_dumb(struct wld_context * context);
+
+#endif
+
diff --git a/src/wld/dumb.c b/src/wld/dumb.c
index 3ae8d8c..b08d098 100644
--- a/src/wld/dumb.c
+++ b/src/wld/dumb.c
@@ -21,191 +21,215 @@
* SOFTWARE.
*/
-#include "wld/drm-private.h"
-#include "wld/drm.h"
-#include "wld/pixman.h"
+#include "drm-private.h"
+#include "drm.h"
+#include "pixman.h"
#include <fcntl.h>
-#include <sys/mman.h>
#include <unistd.h>
+#include <sys/mman.h>
#include <xf86drm.h>
#include <errno.h>
-struct dumb_context {
- struct wld_context base;
- int fd;
+struct dumb_context
+{
+ struct wld_context base;
+ int fd;
};
-struct dumb_buffer {
- struct buffer base;
- struct wld_exporter exporter;
- struct dumb_context *context;
- uint32_t handle;
+struct dumb_buffer
+{
+ struct buffer base;
+ struct wld_exporter exporter;
+ struct dumb_context * context;
+ uint32_t handle;
};
-#include "interface/buffer.h"
#include "interface/context.h"
+#include "interface/buffer.h"
#define DRM_DRIVER_NAME dumb
#include "interface/drm.h"
IMPL(dumb_context, wld_context)
IMPL(dumb_buffer, wld_buffer)
-const struct wld_context_impl *dumb_context_impl = &wld_context_impl;
+const struct wld_context_impl * dumb_context_impl = &wld_context_impl;
-bool driver_device_supported(uint32_t vendor_id, uint32_t device_id) {
- return true;
+bool driver_device_supported(uint32_t vendor_id, uint32_t device_id)
+{
+ return true;
}
-struct wld_context *driver_create_context(int drm_fd) {
- struct dumb_context *context;
+struct wld_context * driver_create_context(int drm_fd)
+{
+ struct dumb_context * context;
- if (!(context = malloc(sizeof *context)))
- return NULL;
+ if (!(context = malloc(sizeof *context)))
+ return NULL;
- context_initialize(&context->base, &wld_context_impl);
- context->fd = drm_fd;
+ context_initialize(&context->base, &wld_context_impl);
+ context->fd = drm_fd;
- return &context->base;
+ return &context->base;
}
-struct wld_renderer *context_create_renderer(struct wld_context *context) {
- return wld_create_renderer(wld_pixman_context);
+struct wld_renderer * context_create_renderer(struct wld_context * context)
+{
+ return wld_create_renderer(wld_pixman_context);
}
-static bool export(struct wld_exporter *exporter, struct wld_buffer *base,
- uint32_t type, union wld_object *object) {
- struct dumb_buffer *buffer = dumb_buffer(base);
-
- switch (type) {
- case WLD_DRM_OBJECT_HANDLE:
- object->u32 = buffer->handle;
- return true;
- case WLD_DRM_OBJECT_PRIME_FD:
- if (drmPrimeHandleToFD(buffer->context->fd, buffer->handle, DRM_CLOEXEC,
- &object->i) != 0) {
- return false;
+static bool export(struct wld_exporter * exporter, struct wld_buffer * base,
+ uint32_t type, union wld_object * object)
+{
+ struct dumb_buffer * buffer = dumb_buffer(base);
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_HANDLE:
+ object->u32 = buffer->handle;
+ return true;
+ case WLD_DRM_OBJECT_PRIME_FD:
+ if (drmPrimeHandleToFD(buffer->context->fd, buffer->handle,
+ DRM_CLOEXEC, &object->i) != 0)
+ {
+ return false;
+ }
+
+ return true;
+ default:
+ return false;
}
-
- return true;
- default:
- return false;
- }
}
-static struct buffer *new_buffer(struct dumb_context *context, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t handle, unsigned long pitch) {
- struct dumb_buffer *buffer;
+static struct buffer * new_buffer(struct dumb_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t handle,
+ unsigned long pitch)
+{
+ struct dumb_buffer * buffer;
- if (!(buffer = malloc(sizeof *buffer)))
- return NULL;
+ if (!(buffer = malloc(sizeof *buffer)))
+ return NULL;
- buffer_initialize(&buffer->base, &wld_buffer_impl, width, height, format,
- pitch);
- buffer->context = context;
- buffer->handle = handle;
- buffer->exporter.export = &export;
- wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
+ buffer_initialize(&buffer->base, &wld_buffer_impl,
+ width, height, format, pitch);
+ buffer->context = context;
+ buffer->handle = handle;
+ buffer->exporter.export = &export;
+ wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
- return &buffer->base;
+ return &buffer->base;
}
-struct buffer *context_create_buffer(struct wld_context *base, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t flags) {
- struct dumb_context *context = dumb_context(base);
- struct buffer *buffer;
- struct drm_mode_create_dumb create_dumb = {
- .height = height,
- .width = width,
- .bpp = format_bytes_per_pixel(format) * 8,
- };
+struct buffer * context_create_buffer(struct wld_context * base,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct dumb_context * context = dumb_context(base);
+ struct buffer * buffer;
+ struct drm_mode_create_dumb create_dumb = {
+ .height = height, .width = width,
+ .bpp = format_bytes_per_pixel(format) * 8,
+ };
- if (drmIoctl(context->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb) != 0)
- goto error0;
+ if (drmIoctl(context->fd, DRM_IOCTL_MODE_CREATE_DUMB, &create_dumb) != 0)
+ goto error0;
- buffer = new_buffer(context, width, height, format, create_dumb.handle,
- create_dumb.pitch);
+ buffer = new_buffer(context, width, height, format,
+ create_dumb.handle, create_dumb.pitch);
- if (!buffer)
- goto error1;
+ if (!buffer)
+ goto error1;
- return buffer;
+ return buffer;
-error1 : {
- struct drm_mode_destroy_dumb destroy_dumb = {.handle = create_dumb.handle};
+ error1:
+ {
+ struct drm_mode_destroy_dumb destroy_dumb = {
+ .handle = create_dumb.handle
+ };
- drmIoctl(context->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
-}
-error0:
- return NULL;
+ drmIoctl(context->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
+ }
+ error0:
+ return NULL;
}
-struct buffer *context_import_buffer(struct wld_context *base, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- struct dumb_context *context = dumb_context(base);
- uint32_t handle;
-
- switch (type) {
- case WLD_DRM_OBJECT_PRIME_FD:
- if (drmPrimeFDToHandle(context->fd, object.i, &handle) != 0)
- return NULL;
- break;
- default:
- return NULL;
- }
+struct buffer * context_import_buffer(struct wld_context * base,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ struct dumb_context * context = dumb_context(base);
+ uint32_t handle;
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_PRIME_FD:
+ if (drmPrimeFDToHandle(context->fd, object.i, &handle) != 0)
+ return NULL;
+ break;
+ default: return NULL;
+ }
- return new_buffer(context, width, height, format, handle, pitch);
+ return new_buffer(context, width, height, format, handle, pitch);
}
-void context_destroy(struct wld_context *base) {
- struct dumb_context *context = dumb_context(base);
+void context_destroy(struct wld_context * base)
+{
+ struct dumb_context * context = dumb_context(base);
- close(context->fd);
- free(context);
+ close(context->fd);
+ free(context);
}
/**** Buffer ****/
-bool buffer_map(struct buffer *base) {
- struct dumb_buffer *buffer = dumb_buffer(&base->base);
- struct drm_mode_map_dumb map_dumb = {.handle = buffer->handle};
- void *data;
+bool buffer_map(struct buffer * base)
+{
+ struct dumb_buffer * buffer = dumb_buffer(&base->base);
+ struct drm_mode_map_dumb map_dumb = { .handle = buffer->handle };
+ void * data;
- if (drmIoctl(buffer->context->fd, DRM_IOCTL_MODE_MAP_DUMB, &map_dumb) != 0) {
- return false;
- }
+ if (drmIoctl(buffer->context->fd, DRM_IOCTL_MODE_MAP_DUMB,
+ &map_dumb) != 0)
+ {
+ return false;
+ }
- data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
- PROT_READ | PROT_WRITE, MAP_SHARED, buffer->context->fd,
- map_dumb.offset);
+ data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
+ PROT_READ | PROT_WRITE, MAP_SHARED,
+ buffer->context->fd, map_dumb.offset);
- if (data == MAP_FAILED)
- return false;
+ if (data == MAP_FAILED)
+ return false;
- buffer->base.base.map = data;
+ buffer->base.base.map = data;
- return true;
+ return true;
}
-bool buffer_unmap(struct buffer *buffer) {
- if (munmap(buffer->base.map, buffer->base.pitch * buffer->base.height) ==
- -1) {
- return false;
- }
+bool buffer_unmap(struct buffer * buffer)
+{
+ if (munmap(buffer->base.map,
+ buffer->base.pitch * buffer->base.height) == -1)
+ {
+ return false;
+ }
- buffer->base.map = NULL;
+ buffer->base.map = NULL;
- return true;
+ return true;
}
-void buffer_destroy(struct buffer *base) {
- struct dumb_buffer *buffer = dumb_buffer(&base->base);
- struct drm_mode_destroy_dumb destroy_dumb = {.handle = buffer->handle};
+void buffer_destroy(struct buffer * base)
+{
+ struct dumb_buffer * buffer = dumb_buffer(&base->base);
+ struct drm_mode_destroy_dumb destroy_dumb = {
+ .handle = buffer->handle
+ };
- drmIoctl(buffer->context->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
- free(buffer);
+ drmIoctl(buffer->context->fd, DRM_IOCTL_MODE_DESTROY_DUMB, &destroy_dumb);
+ free(buffer);
}
+
diff --git a/src/wld/font.c b/src/wld/font.c
index 5389377..36b8a07 100644
--- a/src/wld/font.c
+++ b/src/wld/font.c
@@ -21,198 +21,215 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
+#include "wld-private.h"
#include <fontconfig/fcfreetype.h>
EXPORT
-struct wld_font_context *wld_font_create_context() {
- struct wld_font_context *context;
+struct wld_font_context * wld_font_create_context()
+{
+ struct wld_font_context * context;
- context = malloc(sizeof *context);
+ context = malloc(sizeof *context);
- if (!context)
- goto error0;
+ if (!context)
+ goto error0;
- context->config = FcInitLoadConfigAndFonts();
+ if (FT_Init_FreeType(&context->library) != 0)
+ {
+ DEBUG("Failed to initialize FreeType library\n");
- if (FT_Init_FreeType(&context->library) != 0) {
- DEBUG("Failed to initialize FreeType library\n");
-
- goto error1;
- }
+ goto error1;
+ }
- return context;
+ return context;
-error1:
- free(context);
-error0:
- return NULL;
+ error1:
+ free(context);
+ error0:
+ return NULL;
}
EXPORT
-void wld_font_destroy_context(struct wld_font_context *context) {
- FT_Done_FreeType(context->library);
- free(context);
+void wld_font_destroy_context(struct wld_font_context * context)
+{
+ FT_Done_FreeType(context->library);
+ free(context);
}
EXPORT
-struct wld_font *wld_font_open_name(struct wld_font_context *context,
- const char *name) {
- FcPattern *pattern, *match;
- FcResult result;
+struct wld_font * wld_font_open_name(struct wld_font_context * context,
+ const char * name)
+{
+ FcPattern * pattern, * match;
+ FcResult result;
- DEBUG("Opening font with name: %s\n", name);
+ DEBUG("Opening font with name: %s\n", name);
- pattern = FcNameParse((const FcChar8 *)name);
- FcConfigSubstitute(context->config, pattern, FcMatchPattern);
- FcDefaultSubstitute(pattern);
+ pattern = FcNameParse((const FcChar8 *) name);
+ FcConfigSubstitute(NULL, pattern, FcMatchPattern);
+ FcDefaultSubstitute(pattern);
- match = FcFontMatch(context->config, pattern, &result);
+ match = FcFontMatch(NULL, pattern, &result);
- if (!match)
- return NULL;
+ if (!match)
+ return NULL;
- return wld_font_open_pattern(context, match);
+ return wld_font_open_pattern(context, match);
}
EXPORT
-struct wld_font *wld_font_open_pattern(struct wld_font_context *context,
- FcPattern *match) {
- char *filename;
- struct font *font;
- FcResult result;
- double pixel_size, aspect;
+struct wld_font * wld_font_open_pattern(struct wld_font_context * context,
+ FcPattern * match)
+{
+ char * filename;
+ struct font * font;
+ FcResult result;
+ double pixel_size, aspect;
- font = malloc(sizeof *font);
+ font = malloc(sizeof *font);
- if (!font)
- goto error0;
+ if (!font)
+ goto error0;
- font->context = context;
+ font->context = context;
- result = FcPatternGetString(match, FC_FILE, 0, (FcChar8 **)&filename);
+ result = FcPatternGetString(match, FC_FILE, 0, (FcChar8 **) &filename);
- if (result == FcResultMatch) {
- FT_Error error;
+ if (result == FcResultMatch)
+ {
+ FT_Error error;
- DEBUG("Loading font file: %s\n", filename);
+ DEBUG("Loading font file: %s\n", filename);
- error = FT_New_Face(context->library, filename, 0, &font->face);
+ error = FT_New_Face(context->library, filename, 0, &font->face);
- if (error == 0)
- goto load_face;
- }
+ if (error == 0)
+ goto load_face;
+ }
- result = FcPatternGetFTFace(match, FC_FT_FACE, 0, &font->face);
+ result = FcPatternGetFTFace(match, FC_FT_FACE, 0, &font->face);
- if (result != FcResultMatch) {
- DEBUG("Couldn't determine font filename or FreeType face\n");
- goto error1;
- }
+ if (result != FcResultMatch)
+ {
+ DEBUG("Couldn't determine font filename or FreeType face\n");
+ goto error1;
+ }
-load_face:
- result = FcPatternGetDouble(match, FC_PIXEL_SIZE, 0, &pixel_size);
+ load_face:
+ result = FcPatternGetDouble(match, FC_PIXEL_SIZE, 0, &pixel_size);
- result = FcPatternGetDouble(match, FC_ASPECT, 0, &aspect);
+ result = FcPatternGetDouble(match, FC_ASPECT, 0, &aspect);
- if (result == FcResultNoMatch)
- aspect = 1.0;
+ if (result == FcResultNoMatch)
+ aspect = 1.0;
- if (font->face->face_flags & FT_FACE_FLAG_SCALABLE) {
- FT_F26Dot6 width, height;
+ if (font->face->face_flags & FT_FACE_FLAG_SCALABLE)
+ {
+ FT_F26Dot6 width, height;
- width = ((unsigned int)pixel_size) << 6;
- height = ((unsigned int)(pixel_size * aspect)) << 6;
+ width = ((unsigned int) pixel_size) << 6;
+ height = ((unsigned int) (pixel_size * aspect)) << 6;
- FT_Set_Char_Size(font->face, width, height, 0, 0);
- } else {
- FT_Set_Pixel_Sizes(font->face, (unsigned int)pixel_size,
- (unsigned int)(pixel_size * aspect));
- }
+ FT_Set_Char_Size(font->face, width, height, 0, 0);
+ }
+ else
+ {
+ FT_Set_Pixel_Sizes(font->face, (unsigned int) pixel_size,
+ (unsigned int) (pixel_size * aspect));
+ }
- font->base.ascent = font->face->size->metrics.ascender >> 6;
- font->base.descent = -font->face->size->metrics.descender >> 6;
- font->base.height = font->base.ascent + font->base.descent;
- font->base.max_advance = font->face->size->metrics.max_advance >> 6;
+ font->base.ascent = font->face->size->metrics.ascender >> 6;
+ font->base.descent = -font->face->size->metrics.descender >> 6;
+ font->base.height = font->base.ascent + font->base.descent;
+ font->base.max_advance = font->face->size->metrics.max_advance >> 6;
- font->glyphs = calloc(font->face->num_glyphs, sizeof(struct glyph *));
+ font->glyphs = calloc(font->face->num_glyphs, sizeof(struct glyph *));
- return &font->base;
+ return &font->base;
-error1:
- free(font);
-error0:
- return NULL;
+ error1:
+ free(font);
+ error0:
+ return NULL;
}
EXPORT
-void wld_font_close(struct wld_font *font_base) {
- struct font *font = (void *)font_base;
+void wld_font_close(struct wld_font * font_base)
+{
+ struct font * font = (void *) font_base;
- FT_Done_Face(font->face);
- free(font);
+ FT_Done_Face(font->face);
+ free(font);
}
-bool font_ensure_glyph(struct font *font, FT_UInt glyph_index) {
- if (glyph_index) {
- if (!font->glyphs[glyph_index]) {
- struct glyph *glyph;
+bool font_ensure_glyph(struct font * font, FT_UInt glyph_index)
+{
+ if (glyph_index)
+ {
+ if (!font->glyphs[glyph_index])
+ {
+ struct glyph * glyph;
- glyph = malloc(sizeof *glyph);
+ glyph = malloc(sizeof *glyph);
- if (!glyph)
- return false;
+ if (!glyph)
+ return false;
- FT_Load_Glyph(font->face, glyph_index,
- FT_LOAD_RENDER | FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO);
+ FT_Load_Glyph(font->face, glyph_index, FT_LOAD_RENDER
+ | FT_LOAD_MONOCHROME | FT_LOAD_TARGET_MONO);
- FT_Bitmap_New(&glyph->bitmap);
+ FT_Bitmap_New(&glyph->bitmap);
- FT_Bitmap_Copy(font->context->library, &font->face->glyph->bitmap,
- &glyph->bitmap);
+ FT_Bitmap_Copy(font->context->library,
+ &font->face->glyph->bitmap, &glyph->bitmap);
- glyph->advance = font->face->glyph->metrics.horiAdvance >> 6;
- glyph->x = font->face->glyph->bitmap_left;
- glyph->y = -font->face->glyph->bitmap_top;
+ glyph->advance = font->face->glyph->metrics.horiAdvance >> 6;
+ glyph->x = font->face->glyph->bitmap_left;
+ glyph->y = -font->face->glyph->bitmap_top;
- font->glyphs[glyph_index] = glyph;
- }
+ font->glyphs[glyph_index] = glyph;
+ }
- return true;
- }
+ return true;
+ }
- return false;
+ return false;
}
EXPORT
-bool wld_font_ensure_char(struct wld_font *font_base, uint32_t character) {
- struct font *font = (void *)font_base;
- FT_UInt glyph_index;
+bool wld_font_ensure_char(struct wld_font * font_base, uint32_t character)
+{
+ struct font * font = (void *) font_base;
+ FT_UInt glyph_index;
- glyph_index = FT_Get_Char_Index(font->face, character);
+ glyph_index = FT_Get_Char_Index(font->face, character);
- return font_ensure_glyph(font, glyph_index);
+ return font_ensure_glyph(font, glyph_index);
}
EXPORT
-void wld_font_text_extents_n(struct wld_font *font_base, const char *text,
- int32_t length, struct wld_extents *extents) {
- struct font *font = (void *)font_base;
- int ret;
- uint32_t c;
- FT_UInt glyph_index;
-
- extents->advance = 0;
-
- while ((ret = FcUtf8ToUcs4((FcChar8 *)text, &c, length) > 0) && c != '\0') {
- length -= ret;
- text += ret;
- glyph_index = FT_Get_Char_Index(font->face, c);
-
- if (!font_ensure_glyph(font, glyph_index))
- continue;
-
- extents->advance += font->glyphs[glyph_index]->advance;
- }
+void wld_font_text_extents_n(struct wld_font * font_base,
+ const char * text, int32_t length,
+ struct wld_extents * extents)
+{
+ struct font * font = (void *) font_base;
+ int ret;
+ uint32_t c;
+ FT_UInt glyph_index;
+
+ extents->advance = 0;
+
+ while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length) > 0) && c != '\0')
+ {
+ length -= ret;
+ text += ret;
+ glyph_index = FT_Get_Char_Index(font->face, c);
+
+ if (!font_ensure_glyph(font, glyph_index))
+ continue;
+
+ extents->advance += font->glyphs[glyph_index]->advance;
+ }
}
+
diff --git a/src/wld/intel.c b/src/wld/intel.c
new file mode 100644
index 0000000..cdbb240
--- /dev/null
+++ b/src/wld/intel.c
@@ -0,0 +1,390 @@
+/* wld: intel.c
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "drm-private.h"
+#include "drm.h"
+#include "intel/batch.h"
+#include "intel/blt.h"
+#include "wld-private.h"
+
+#include <unistd.h>
+#include <intel_bufmgr.h>
+#include <i915_drm.h>
+
+struct intel_context
+{
+ struct wld_context base;
+ drm_intel_bufmgr * bufmgr;
+};
+
+struct intel_renderer
+{
+ struct wld_renderer base;
+ struct intel_batch batch;
+ struct intel_buffer * target;
+};
+
+struct intel_buffer
+{
+ struct buffer base;
+ struct wld_exporter exporter;
+ drm_intel_bo * bo;
+};
+
+#include "interface/context.h"
+#include "interface/renderer.h"
+#include "interface/buffer.h"
+#define DRM_DRIVER_NAME intel
+#include "interface/drm.h"
+IMPL(intel_context, wld_context)
+IMPL(intel_renderer, wld_renderer)
+IMPL(intel_buffer, wld_buffer)
+
+/**** DRM driver ****/
+bool driver_device_supported(uint32_t vendor_id, uint32_t device_id)
+{
+ return vendor_id == 0x8086;
+}
+
+struct wld_context * driver_create_context(int drm_fd)
+{
+ struct intel_context * context;
+
+ context = malloc(sizeof *context);
+
+ if (!context)
+ goto error0;
+
+ context_initialize(&context->base, &wld_context_impl);
+ context->bufmgr = drm_intel_bufmgr_gem_init(drm_fd, INTEL_BATCH_SIZE);
+
+ if (!context->bufmgr)
+ goto error1;
+
+ return &context->base;
+
+ error1:
+ free(context);
+ error0:
+ return NULL;
+}
+
+/**** Context ****/
+struct wld_renderer * context_create_renderer(struct wld_context * base)
+{
+ struct intel_context * context = intel_context(base);
+ struct intel_renderer * renderer;
+
+ if (!(renderer = malloc(sizeof *renderer)))
+ goto error0;
+
+ if (!(intel_batch_initialize(&renderer->batch, context->bufmgr)))
+ goto error1;
+
+ renderer_initialize(&renderer->base, &wld_renderer_impl);
+
+ return &renderer->base;
+
+ error1:
+ free(renderer);
+ error0:
+ return NULL;
+}
+
+static bool export(struct wld_exporter * exporter, struct wld_buffer * base,
+ uint32_t type, union wld_object * object)
+{
+ struct intel_buffer * buffer = intel_buffer(base);
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_HANDLE:
+ object->u32 = buffer->bo->handle;
+ return true;
+ case WLD_DRM_OBJECT_PRIME_FD:
+ if (drm_intel_bo_gem_export_to_prime(buffer->bo, &object->i) != 0)
+ return false;
+ return true;
+ default:
+ return false;
+ }
+}
+
+static struct buffer * new_buffer(uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch,
+ drm_intel_bo * bo)
+{
+ struct intel_buffer * buffer;
+
+ if (!(buffer = malloc(sizeof *buffer)))
+ return NULL;
+
+ buffer_initialize(&buffer->base, &wld_buffer_impl,
+ width, height, format, pitch);
+ buffer->bo = bo;
+ buffer->exporter.export = &export;
+ wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
+
+ return &buffer->base;
+}
+
+struct buffer * context_create_buffer(struct wld_context * base,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct intel_context * context = intel_context(base);
+ struct buffer * buffer;
+ drm_intel_bo * bo;
+ uint32_t tiling_mode = width >= 128 && !(flags & WLD_FLAG_CURSOR) ? I915_TILING_X : I915_TILING_NONE;
+ unsigned long pitch;
+
+ bo = drm_intel_bo_alloc_tiled(context->bufmgr, "buffer", width, height, 4,
+ &tiling_mode, &pitch, 0);
+
+ if (!bo)
+ goto error0;
+
+ if (!(buffer = new_buffer(width, height, format, pitch, bo)))
+ goto error1;
+
+ return buffer;
+
+ error1:
+ drm_intel_bo_unreference(bo);
+ error0:
+ return NULL;
+}
+
+struct buffer * context_import_buffer(struct wld_context * base,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ struct intel_context * context = intel_context(base);
+ struct buffer * buffer;
+ drm_intel_bo * bo;
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_PRIME_FD:
+ {
+ uint32_t size = width * height * format_bytes_per_pixel(format);
+ bo = drm_intel_bo_gem_create_from_prime(context->bufmgr,
+ object.i, size);
+ break;
+ }
+ default: bo = NULL;
+ };
+
+ if (!bo)
+ goto error0;
+
+ if (!(buffer = new_buffer(width, height, format, pitch, bo)))
+ goto error1;
+
+ return buffer;
+
+ error1:
+ drm_intel_bo_unreference(bo);
+ error0:
+ return NULL;
+}
+
+void context_destroy(struct wld_context * base)
+{
+ struct intel_context * context = intel_context(base);
+
+ drm_intel_bufmgr_destroy(context->bufmgr);
+ free(context);
+}
+
+/**** Renderer ****/
+uint32_t renderer_capabilities(struct wld_renderer * renderer,
+ struct buffer * buffer)
+{
+ if (buffer->base.impl == &wld_buffer_impl)
+ return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
+
+ return 0;
+}
+
+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+
+ if (buffer && buffer->base.impl != &wld_buffer_impl)
+ return false;
+
+ renderer->target = buffer ? intel_buffer(&buffer->base) : NULL;
+
+ return true;
+}
+
+void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
+ int32_t x, int32_t y,
+ uint32_t width, uint32_t height)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+ struct intel_buffer * dst = renderer->target;
+
+ xy_color_blt(&renderer->batch, dst->bo, dst->base.base.pitch,
+ x, y, x + width, y + height, color);
+}
+
+void renderer_copy_rectangle(struct wld_renderer * base,
+ struct buffer * buffer_base,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+
+ if (buffer_base->base.impl != &wld_buffer_impl)
+ return;
+
+ struct intel_buffer * src = intel_buffer(&buffer_base->base),
+ * dst = renderer->target;
+
+ xy_src_copy_blt(&renderer->batch,
+ src->bo, src->base.base.pitch, src_x, src_y,
+ dst->bo, dst->base.base.pitch, dst_x, dst_y, width, height);
+}
+
+void renderer_draw_text(struct wld_renderer * base,
+ struct font * font, uint32_t color,
+ int32_t x, int32_t y, const char * text,
+ uint32_t length, struct wld_extents * extents)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+ struct intel_buffer * dst = renderer->target;
+ int ret;
+ struct glyph * glyph;
+ uint32_t row;
+ FT_UInt glyph_index;
+ uint32_t c;
+ uint8_t immediate[512];
+ uint8_t * byte;
+ int32_t origin_x = x;
+
+ xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC,
+ 0, color, dst->bo, dst->base.base.pitch);
+
+ if (length == -1)
+ length = strlen(text);
+
+ while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0')
+ {
+ text += ret;
+ length -= ret;
+ glyph_index = FT_Get_Char_Index(font->face, c);
+
+ if (!font_ensure_glyph(font, glyph_index))
+ continue;
+
+ glyph = font->glyphs[glyph_index];
+
+ if (glyph->bitmap.width == 0 || glyph->bitmap.rows == 0)
+ goto advance;
+
+ byte = immediate;
+
+ /* XY_TEXT_IMMEDIATE requires a pitch with no extra bytes */
+ for (row = 0; row < glyph->bitmap.rows; ++row)
+ {
+ memcpy(byte, glyph->bitmap.buffer + (row * glyph->bitmap.pitch),
+ (glyph->bitmap.width + 7) / 8);
+ byte += (glyph->bitmap.width + 7) / 8;
+ }
+
+ retry:
+ ret = xy_text_immediate_blt(&renderer->batch, dst->bo,
+ origin_x + glyph->x, y + glyph->y,
+ origin_x + glyph->x + glyph->bitmap.width,
+ y + glyph->y + glyph->bitmap.rows,
+ (byte - immediate + 3) / 4,
+ (uint32_t *) immediate);
+
+ if (ret == INTEL_BATCH_NO_SPACE)
+ {
+ intel_batch_flush(&renderer->batch);
+ xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC,
+ 0, color, dst->bo, dst->base.base.pitch);
+ goto retry;
+ }
+
+ advance:
+ origin_x += glyph->advance;
+ }
+
+ if (extents)
+ extents->advance = origin_x - x;
+}
+
+void renderer_flush(struct wld_renderer * base)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+
+ intel_batch_flush(&renderer->batch);
+}
+
+void renderer_destroy(struct wld_renderer * base)
+{
+ struct intel_renderer * renderer = intel_renderer(base);
+
+ intel_batch_finalize(&renderer->batch);
+ free(renderer);
+}
+
+/**** Buffer ****/
+bool buffer_map(struct buffer * base)
+{
+ struct intel_buffer * buffer = intel_buffer(&base->base);
+
+ if (drm_intel_gem_bo_map_gtt(buffer->bo) != 0)
+ return false;
+
+ buffer->base.base.map = buffer->bo->virtual;
+
+ return true;
+}
+
+bool buffer_unmap(struct buffer * base)
+{
+ struct intel_buffer * buffer = intel_buffer(&base->base);
+
+ if (drm_intel_gem_bo_unmap_gtt(buffer->bo) != 0)
+ return false;
+
+ buffer->base.base.map = NULL;
+
+ return true;
+}
+
+void buffer_destroy(struct buffer * base)
+{
+ struct intel_buffer * buffer = intel_buffer(&base->base);
+
+ drm_intel_bo_unreference(buffer->bo);
+ free(buffer);
+}
+
diff --git a/src/wld/intel/batch.c b/src/wld/intel/batch.c
index ce15ef1..2618a4a 100644
--- a/src/wld/intel/batch.c
+++ b/src/wld/intel/batch.c
@@ -27,69 +27,97 @@
#include <i915_drm.h>
#include <stdlib.h>
-static const struct intel_device_info device_info_i965 = {.gen = 4};
-static const struct intel_device_info device_info_g4x = {.gen = 4};
-static const struct intel_device_info device_info_ilk = {.gen = 5};
-static const struct intel_device_info device_info_snb_gt1 = {.gen = 6};
-static const struct intel_device_info device_info_snb_gt2 = {.gen = 6};
-static const struct intel_device_info device_info_ivb_gt1 = {.gen = 7};
-static const struct intel_device_info device_info_ivb_gt2 = {.gen = 7};
-static const struct intel_device_info device_info_byt = {.gen = 7};
-static const struct intel_device_info device_info_hsw_gt1 = {.gen = 7};
-static const struct intel_device_info device_info_hsw_gt2 = {.gen = 7};
-static const struct intel_device_info device_info_hsw_gt3 = {.gen = 7};
-
-static const struct intel_device_info *device_info(int device_id) {
- switch (device_id) {
-#define CHIPSET(device_id, type, name) \
- case device_id: \
- return &device_info_##type;
+static const struct intel_device_info device_info_i965 = { .gen = 4 };
+static const struct intel_device_info device_info_g4x = { .gen = 4 };
+static const struct intel_device_info device_info_ilk = { .gen = 5 };
+static const struct intel_device_info device_info_snb_gt1 = { .gen = 6 };
+static const struct intel_device_info device_info_snb_gt2 = { .gen = 6 };
+static const struct intel_device_info device_info_ivb_gt1 = { .gen = 7 };
+static const struct intel_device_info device_info_ivb_gt2 = { .gen = 7 };
+static const struct intel_device_info device_info_byt = { .gen = 7 };
+static const struct intel_device_info device_info_hsw_gt1 = { .gen = 7 };
+static const struct intel_device_info device_info_hsw_gt2 = { .gen = 7 };
+static const struct intel_device_info device_info_hsw_gt3 = { .gen = 7 };
+static const struct intel_device_info device_info_bdw_gt1 = { .gen = 8 };
+static const struct intel_device_info device_info_bdw_gt2 = { .gen = 8 };
+static const struct intel_device_info device_info_bdw_gt3 = { .gen = 8 };
+static const struct intel_device_info device_info_chv = { .gen = 8 };
+static const struct intel_device_info device_info_skl_gt1 = { .gen = 9 };
+static const struct intel_device_info device_info_skl_gt2 = { .gen = 9 };
+static const struct intel_device_info device_info_skl_gt3 = { .gen = 9 };
+static const struct intel_device_info device_info_skl_gt4 = { .gen = 9 };
+static const struct intel_device_info device_info_bxt = { .gen = 9 };
+static const struct intel_device_info device_info_bxt_2x6 = { .gen = 9 };
+static const struct intel_device_info device_info_kbl_gt1 = { .gen = 9 };
+static const struct intel_device_info device_info_kbl_gt1_5 = { .gen = 9 };
+static const struct intel_device_info device_info_kbl_gt2 = { .gen = 9 };
+static const struct intel_device_info device_info_kbl_gt3 = { .gen = 9 };
+static const struct intel_device_info device_info_kbl_gt4 = { .gen = 9 };
+static const struct intel_device_info device_info_glk = { .gen = 9 };
+static const struct intel_device_info device_info_glk_2x6 = { .gen = 9 };
+static const struct intel_device_info device_info_cfl_gt1 = { .gen = 9 };
+static const struct intel_device_info device_info_cfl_gt2 = { .gen = 9 };
+static const struct intel_device_info device_info_cfl_gt3 = { .gen = 9 };
+static const struct intel_device_info device_info_cnl_2x8 = { .gen = 10 };
+static const struct intel_device_info device_info_cnl_3x8 = { .gen = 10 };
+static const struct intel_device_info device_info_cnl_4x8 = { .gen = 10 };
+static const struct intel_device_info device_info_cnl_5x8 = { .gen = 10 };
+
+static const struct intel_device_info * device_info(int device_id)
+{
+ switch (device_id)
+ {
+#define CHIPSET(device_id, type, name) \
+ case device_id: return &device_info_ ## type;
#include "i965_pci_ids.h"
#undef CHIPSET
- default:
- return NULL;
- }
+ default: return NULL;
+ }
}
-bool intel_batch_initialize(struct intel_batch *batch,
- drm_intel_bufmgr *bufmgr) {
- int device_id = drm_intel_bufmgr_gem_get_devid(bufmgr);
+bool intel_batch_initialize(struct intel_batch * batch,
+ drm_intel_bufmgr * bufmgr)
+{
+ int device_id = drm_intel_bufmgr_gem_get_devid(bufmgr);
- batch->command_count = 0;
- batch->device_info = device_info(device_id);
+ batch->command_count = 0;
+ batch->device_info = device_info(device_id);
- if (!batch->device_info)
- return false;
+ if (!batch->device_info)
+ return false;
- /* Alignment argument (4096) is not used */
- batch->bo =
- drm_intel_bo_alloc(bufmgr, "batchbuffer", sizeof batch->commands, 4096);
+ /* Alignment argument (4096) is not used */
+ batch->bo = drm_intel_bo_alloc(bufmgr, "batchbuffer",
+ sizeof batch->commands, 4096);
- if (!batch->bo)
- return false;
+ if (!batch->bo)
+ return false;
- return true;
+ return true;
}
-void intel_batch_finalize(struct intel_batch *batch) {
- drm_intel_bo_unreference(batch->bo);
+void intel_batch_finalize(struct intel_batch * batch)
+{
+ drm_intel_bo_unreference(batch->bo);
}
-void intel_batch_flush(struct intel_batch *batch) {
- if (batch->command_count == 0)
- return;
+void intel_batch_flush(struct intel_batch * batch)
+{
+ if (batch->command_count == 0)
+ return;
- intel_batch_add_dword(batch, MI_BATCH_BUFFER_END);
+ intel_batch_add_dword(batch, MI_BATCH_BUFFER_END);
- /* Pad the batch buffer to the next quad-word. */
- if (batch->command_count & 1)
- intel_batch_add_dword(batch, MI_NOOP);
+ /* Pad the batch buffer to the next quad-word. */
+ if (batch->command_count & 1)
+ intel_batch_add_dword(batch, MI_NOOP);
- drm_intel_bo_subdata(batch->bo, 0, batch->command_count << 2,
- batch->commands);
- drm_intel_bo_mrb_exec(batch->bo, batch->command_count << 2, NULL, 0, 0,
- batch->device_info->gen >= 6 ? I915_EXEC_BLT
- : I915_EXEC_DEFAULT);
- drm_intel_gem_bo_clear_relocs(batch->bo, 0);
- batch->command_count = 0;
+ drm_intel_bo_subdata(batch->bo, 0, batch->command_count << 2,
+ batch->commands);
+ drm_intel_bo_mrb_exec(batch->bo, batch->command_count << 2, NULL, 0, 0,
+ GEN(batch, 6) ? I915_EXEC_BLT
+ : I915_EXEC_DEFAULT);
+ drm_intel_gem_bo_clear_relocs(batch->bo, 0);
+ batch->command_count = 0;
}
+
diff --git a/src/wld/intel/batch.h b/src/wld/intel/batch.h
index 682b41c..cc9d1d9 100644
--- a/src/wld/intel/batch.h
+++ b/src/wld/intel/batch.h
@@ -24,69 +24,83 @@
#ifndef WLD_INTEL_BATCH_H
#define WLD_INTEL_BATCH_H
-#include <intel_bufmgr.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stdint.h>
+#include <intel_bufmgr.h>
#define INTEL_BATCH_MAX_COMMANDS (1 << 13)
#define INTEL_BATCH_RESERVED_COMMANDS 2
#define INTEL_BATCH_SIZE (INTEL_BATCH_MAX_COMMANDS << 2)
-enum intel_batch_result { INTEL_BATCH_SUCCESS, INTEL_BATCH_NO_SPACE };
+enum intel_batch_result
+{
+ INTEL_BATCH_SUCCESS,
+ INTEL_BATCH_NO_SPACE
+};
-struct intel_device_info {
- int gen;
+struct intel_device_info
+{
+ int gen;
};
-struct intel_batch {
- const struct intel_device_info *device_info;
- drm_intel_bo *bo;
- uint32_t commands[INTEL_BATCH_MAX_COMMANDS];
- uint32_t command_count;
+#define GEN(b, m) ((b)->device_info->gen >= (m))
+
+struct intel_batch
+{
+ const struct intel_device_info * device_info;
+ drm_intel_bo * bo;
+ uint32_t commands[INTEL_BATCH_MAX_COMMANDS];
+ uint32_t command_count;
};
-bool intel_batch_initialize(struct intel_batch *batch,
- drm_intel_bufmgr *bufmgr);
+bool intel_batch_initialize(struct intel_batch * batch,
+ drm_intel_bufmgr * bufmgr);
-void intel_batch_finalize(struct intel_batch *batch);
+void intel_batch_finalize(struct intel_batch * batch);
-void intel_batch_flush(struct intel_batch *batch);
+void intel_batch_flush(struct intel_batch * batch);
-static inline uint32_t intel_batch_check_space(struct intel_batch *batch,
- uint32_t size) {
- return (INTEL_BATCH_MAX_COMMANDS - INTEL_BATCH_RESERVED_COMMANDS -
- batch->command_count) >= size;
+static inline uint32_t intel_batch_check_space(struct intel_batch * batch,
+ uint32_t size)
+{
+ return (INTEL_BATCH_MAX_COMMANDS - INTEL_BATCH_RESERVED_COMMANDS
+ - batch->command_count) >= size;
}
-static inline void intel_batch_ensure_space(struct intel_batch *batch,
- uint32_t size) {
- if (!intel_batch_check_space(batch, size))
- intel_batch_flush(batch);
+static inline void intel_batch_ensure_space(struct intel_batch * batch, uint32_t size)
+{
+ if (!intel_batch_check_space(batch, size))
+ intel_batch_flush(batch);
}
-static inline void intel_batch_add_dword(struct intel_batch *batch,
- uint32_t dword) {
- batch->commands[batch->command_count++] = dword;
+static inline void intel_batch_add_dword(struct intel_batch * batch,
+ uint32_t dword)
+{
+ batch->commands[batch->command_count++] = dword;
}
-static inline void intel_batch_add_dwords_va(struct intel_batch *batch,
- uint32_t count, va_list dwords) {
- while (count--)
- intel_batch_add_dword(batch, va_arg(dwords, uint32_t));
+static inline void intel_batch_add_dwords_va(struct intel_batch * batch,
+ uint32_t count, va_list dwords)
+{
+ while (count--)
+ intel_batch_add_dword(batch, va_arg(dwords, uint32_t));
}
-static inline void intel_batch_add_dwords(struct intel_batch *batch,
- uint32_t count, ...) {
- va_list dwords;
- va_start(dwords, count);
- intel_batch_add_dwords_va(batch, count, dwords);
- va_end(dwords);
+static inline void intel_batch_add_dwords(struct intel_batch * batch,
+ uint32_t count, ...)
+{
+ va_list dwords;
+ va_start(dwords, count);
+ intel_batch_add_dwords_va(batch, count, dwords);
+ va_end(dwords);
}
-static inline uint32_t intel_batch_offset(struct intel_batch *batch,
- uint32_t command_index) {
- return (batch->command_count + command_index) << 2;
+static inline uint32_t intel_batch_offset(struct intel_batch * batch,
+ uint32_t command_index)
+{
+ return (batch->command_count + command_index) << 2;
}
#endif
+
diff --git a/src/wld/intel/blt.h b/src/wld/intel/blt.h
index 41670d2..0d9486b 100644
--- a/src/wld/intel/blt.h
+++ b/src/wld/intel/blt.h
@@ -29,287 +29,360 @@
#define INTEL_CLIENT_BLT 0x2
-enum blt_op {
- BLT_OP_XY_SETUP_BLT = 0x01,
- BLT_OP_XY_TEXT_BLT = 0x26,
- BLT_OP_XY_TEXT_IMMEDIATE_BLT = 0x31,
- BLT_OP_XY_COLOR_BLT = 0x50,
- BLT_OP_XY_SRC_COPY_BLT = 0x53
+enum blt_op
+{
+ BLT_OP_XY_SETUP_BLT = 0x01,
+ BLT_OP_XY_TEXT_BLT = 0x26,
+ BLT_OP_XY_TEXT_IMMEDIATE_BLT = 0x31,
+ BLT_OP_XY_COLOR_BLT = 0x50,
+ BLT_OP_XY_SRC_COPY_BLT = 0x53
};
-enum blt_32bpp_mask {
- BLT_32BPP_MASK_ALPHA = (1 << 0),
- BLT_32BPP_MASK_RGB = (1 << 1)
+enum blt_32bpp_mask
+{
+ BLT_32BPP_MASK_ALPHA = (1 << 0),
+ BLT_32BPP_MASK_RGB = (1 << 1)
};
-enum blt_packing { BLT_PACKING_BIT = 0, BLT_PACKING_BYTE = 1 };
+enum blt_packing
+{
+ BLT_PACKING_BIT = 0,
+ BLT_PACKING_BYTE = 1
+};
-enum blt_color_depth {
- BLT_COLOR_DEPTH_8BIT = 0x0,
- BLT_COLOR_DEPTH_16BIT_565 = 0x1,
- BLT_COLOR_DEPTH_16BIT_1555 = 0x2,
- BLT_COLOR_DEPTH_32BIT = 0x3
+enum blt_color_depth
+{
+ BLT_COLOR_DEPTH_8BIT = 0x0,
+ BLT_COLOR_DEPTH_16BIT_565 = 0x1,
+ BLT_COLOR_DEPTH_16BIT_1555 = 0x2,
+ BLT_COLOR_DEPTH_32BIT = 0x3
};
-enum blt_raster_operation {
- BLT_RASTER_OPERATION_SRC = 0xcc,
- BLT_RASTER_OPERATION_PAT = 0xf0
+enum blt_raster_operation
+{
+ BLT_RASTER_OPERATION_SRC = 0xcc,
+ BLT_RASTER_OPERATION_PAT = 0xf0
};
/* BR00 : BLT Opcode & Control */
-#define BLT_BR00_CLIENT(x) ((x) << 29) /* 31:29 */
-#define BLT_BR00_OP(x) ((x) << 22) /* 28:22 */
-#define BLT_BR00_32BPP_MASK(x) ((x) << 20) /* 21:20 */
- /* 19:17 */
-#define BLT_BR00_PACKING(x) ((x) << 16) /* 16 */
-#define BLT_BR00_SRC_TILING_ENABLE(x) ((x) << 15) /* 15 */
- /* 14:12 */
-#define BLT_BR00_DST_TILING_ENABLE(x) ((x) << 11) /* 11 */
-#define BLT_BR00_DWORD_LENGTH(x) ((x) << 0) /* 7:0 */
+#define BLT_BR00_CLIENT(x) ((x) << 29) /* 31:29 */
+#define BLT_BR00_OP(x) ((x) << 22) /* 28:22 */
+#define BLT_BR00_32BPP_MASK(x) ((x) << 20) /* 21:20 */
+ /* 19:17 */
+#define BLT_BR00_PACKING(x) ((x) << 16) /* 16 */
+#define BLT_BR00_SRC_TILING_ENABLE(x) ((x) << 15) /* 15 */
+ /* 14:12 */
+#define BLT_BR00_DST_TILING_ENABLE(x) ((x) << 11) /* 11 */
+#define BLT_BR00_DWORD_LENGTH(x) ((x) << 0) /* 7:0 */
/* BR01 : Setup BLT Raster OP, Control, and Destination Offset */
-#define BLT_BR01_SOLID_PATTERN(x) ((x) << 31) /* 31 */
-#define BLT_BR01_CLIPPING_ENABLE(x) ((x) << 30) /* 30 */
-#define BLT_BR01_MONO_SRC_TRANSPARENCY(x) ((x) << 29) /* 29 */
-#define BLT_BR01_MONO_PAT_TRANSPARENCY(x) ((x) << 28) /* 28 */
-#define BLT_BR01_COLOR_DEPTH(x) ((x) << 24) /* 25:24 */
-#define BLT_BR01_RASTER_OPERATION(x) ((x) << 16) /* 23:16 */
-#define BLT_BR01_DST_PITCH(x) ((x) << 0) /* 15:0 */
+#define BLT_BR01_SOLID_PATTERN(x) ((x) << 31) /* 31 */
+#define BLT_BR01_CLIPPING_ENABLE(x) ((x) << 30) /* 30 */
+#define BLT_BR01_MONO_SRC_TRANSPARENCY(x) ((x) << 29) /* 29 */
+#define BLT_BR01_MONO_PAT_TRANSPARENCY(x) ((x) << 28) /* 28 */
+#define BLT_BR01_COLOR_DEPTH(x) ((x) << 24) /* 25:24 */
+#define BLT_BR01_RASTER_OPERATION(x) ((x) << 16) /* 23:16 */
+#define BLT_BR01_DST_PITCH(x) ((x) << 0) /* 15:0 */
/* BR05 : Setup Expansion Background Color */
-#define BLT_BR05_BACKGROUND_COLOR(x) ((x) << 0) /* 31:0 */
+#define BLT_BR05_BACKGROUND_COLOR(x) ((x) << 0) /* 31:0 */
/* BR06 : Setup Expansion Foreground Color */
-#define BLT_BR06_FOREGROUND_COLOR(x) ((x) << 0) /* 31:0 */
+#define BLT_BR06_FOREGROUND_COLOR(x) ((x) << 0) /* 31:0 */
-/* BR07 : Setup Blit Color Pattern Address */
-/* 31:29 */
-#define BLT_BR07_PAT_ADDRESS(x) ((x) << 6) /* 28:6 */
- /* 5:0 */
+/* BR07 : Setup Blit Color Pattern Address Low Bits */
+ /* 31:29 */
+#define BLT_BR07_PAT_ADDRESS(x) ((x) << 6) /* 28:6 */
+ /* 5:0 */
-/* BR09 : Destination Address */
-/* 31:29 */
-#define BLT_BR09_DST_ADDRESS(x) ((x) << 0) /* 28:0 */
+/* BR09 : Destination Address Low Bits */
+ /* 31:29 */
+#define BLT_BR09_DST_ADDRESS(x) ((x) << 0) /* 28:0 */
/* BR11 : Source Pitch */
-/* 31:16 */
-#define BLT_BR11_SRC_PITCH(x) ((x) << 0) /* 15:0 */
+ /* 31:16 */
+#define BLT_BR11_SRC_PITCH(x) ((x) << 0) /* 15:0 */
-/* BR12 : Source Address */
-/* 31:29 */
-#define BLT_BR12_SRC_ADDRESS(x) ((x) << 0) /* 28:0 */
+/* BR12 : Source Address Low Bits */
+ /* 31:29 */
+#define BLT_BR12_SRC_ADDRESS(x) ((x) << 0) /* 28:0 */
/* BR13 : BLT Raster OP, Control, and Destination Pitch */
-#define BLT_BR13_SOLID_PATTERN(x) ((x) << 31) /* 31 */
-#define BLT_BR13_CLIPPING_ENABLE(x) ((x) << 30) /* 30 */
-#define BLT_BR13_MONO_SRC_TRANSPARENT(x) ((x) << 29) /* 29 */
-#define BLT_BR13_MONO_PAT_TRANSPARENT(x) ((x) << 28) /* 28 */
-#define BLT_BR13_COLOR_DEPTH(x) ((x) << 24) /* 25:24 */
-#define BLT_BR13_RASTER_OPERATION(x) ((x) << 16) /* 23:16 */
-#define BLT_BR13_DST_PITCH(x) ((x) << 0) /* 15:0 */
+#define BLT_BR13_SOLID_PATTERN(x) ((x) << 31) /* 31 */
+#define BLT_BR13_CLIPPING_ENABLE(x) ((x) << 30) /* 30 */
+#define BLT_BR13_MONO_SRC_TRANSPARENT(x) ((x) << 29) /* 29 */
+#define BLT_BR13_MONO_PAT_TRANSPARENT(x) ((x) << 28) /* 28 */
+#define BLT_BR13_COLOR_DEPTH(x) ((x) << 24) /* 25:24 */
+#define BLT_BR13_RASTER_OPERATION(x) ((x) << 16) /* 23:16 */
+#define BLT_BR13_DST_PITCH(x) ((x) << 0) /* 15:0 */
/* BR16 : Pattern Expansion Background & Solid Pattern Color */
-#define BLT_BR16_COLOR(x) ((x) << 0) /* 31 : 0 */
+#define BLT_BR16_COLOR(x) ((x) << 0) /* 31 : 0 */
/* BR22 : Destination Top Left */
-#define BLT_BR22_DST_Y1(x) ((x) << 16) /* 31:16 */
-#define BLT_BR22_DST_X1(x) ((x) << 0) /* 16:0 */
+#define BLT_BR22_DST_Y1(x) ((x) << 16) /* 31:16 */
+#define BLT_BR22_DST_X1(x) ((x) << 0) /* 16:0 */
/* BR23 : Destination Bottom Right */
-#define BLT_BR23_DST_Y2(x) ((x) << 16) /* 31:16 */
-#define BLT_BR23_DST_X2(x) ((x) << 0) /* 16:0 */
+#define BLT_BR23_DST_Y2(x) ((x) << 16) /* 31:16 */
+#define BLT_BR23_DST_X2(x) ((x) << 0) /* 16:0 */
/* BR24 : Clip Rectangle Top Left */
-/* 31 */
-#define BLT_BR24_CLP_Y1(x) ((x) << 16) /* 30:16 */
- /* 15 */
-#define BLT_BR24_CLP_X1(x) ((x) << 0) /* 14:0 */
+ /* 31 */
+#define BLT_BR24_CLP_Y1(x) ((x) << 16) /* 30:16 */
+ /* 15 */
+#define BLT_BR24_CLP_X1(x) ((x) << 0) /* 14:0 */
/* BR25 : Clip Rectangle Bottom Right */
-/* 31 */
-#define BLT_BR25_CLP_Y2(x) ((x) << 16) /* 30:16 */
- /* 15 */
-#define BLT_BR25_CLP_X2(x) ((x) << 0) /* 14:0 */
+ /* 31 */
+#define BLT_BR25_CLP_Y2(x) ((x) << 16) /* 30:16 */
+ /* 15 */
+#define BLT_BR25_CLP_X2(x) ((x) << 0) /* 14:0 */
/* BR26 : Source Top Left */
-#define BLT_BR26_SRC_Y1(x) ((x) << 16) /* 31:16 */
-#define BLT_BR26_SRC_X1(x) ((x) << 0) /* 15:0 */
-
-static inline void
-xy_setup_blt(struct intel_batch *batch, bool monochrome_source_transparency,
- uint8_t raster_operation, uint32_t background_color,
- uint32_t foreground_color, drm_intel_bo *dst, uint16_t dst_pitch) {
- uint32_t tiling_mode, swizzle_mode;
-
- intel_batch_ensure_space(batch, 8);
-
- drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
- drm_intel_bo_emit_reloc_fence(batch->bo, intel_batch_offset(batch, 4), dst, 0,
- I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
-
- intel_batch_add_dwords(
- batch, 8,
- BLT_BR00_CLIENT(INTEL_CLIENT_BLT) | BLT_BR00_OP(BLT_OP_XY_SETUP_BLT) |
- BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB) |
- BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DWORD_LENGTH(6),
-
- BLT_BR01_CLIPPING_ENABLE(false) |
- BLT_BR01_MONO_SRC_TRANSPARENCY(monochrome_source_transparency) |
- BLT_BR01_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT) |
- BLT_BR01_RASTER_OPERATION(raster_operation) |
- BLT_BR01_DST_PITCH(tiling_mode == I915_TILING_NONE ? dst_pitch
- : dst_pitch >> 2),
-
- /* XXX: No clipping yet */
- BLT_BR24_CLP_Y1(0) | BLT_BR24_CLP_X1(0),
-
- BLT_BR25_CLP_Y2(0) | BLT_BR25_CLP_X2(0),
-
- BLT_BR09_DST_ADDRESS(dst->offset),
- BLT_BR05_BACKGROUND_COLOR(background_color),
- BLT_BR06_FOREGROUND_COLOR(foreground_color), BLT_BR07_PAT_ADDRESS(0));
+#define BLT_BR26_SRC_Y1(x) ((x) << 16) /* 31:16 */
+#define BLT_BR26_SRC_X1(x) ((x) << 0) /* 15:0 */
+
+/* BR27 : Destination Address High Bits */
+ /* 31:16 */
+#define BLT_BR27_DST_ADDRESS_HI(x) ((x) << 0) /* 15:0 */
+
+/* BR28 : Source Address High Bits */
+ /* 31:16 */
+#define BLT_BR28_SRC_ADDRESS_HI(x) ((x) << 0) /* 15:0 */
+
+/* BR30 : Setup Blit Color Pattern Address High Bits */
+ /* 31:16 */
+#define BLT_BR30_PAT_ADDRESS_HI(x) ((x) << 0) /* 15:0 */
+
+static inline void xy_setup_blt(struct intel_batch * batch,
+ bool monochrome_source_transparency,
+ uint8_t raster_operation,
+ uint32_t background_color,
+ uint32_t foreground_color,
+ drm_intel_bo * dst, uint16_t dst_pitch)
+{
+ uint32_t tiling_mode, swizzle_mode;
+
+ intel_batch_ensure_space(batch, GEN(batch, 8) ? 10 : 8);
+
+ drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
+ drm_intel_bo_emit_reloc_fence
+ (batch->bo, intel_batch_offset(batch, 4), dst, 0,
+ I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
+
+ intel_batch_add_dwords(batch, 4,
+ BLT_BR00_CLIENT(INTEL_CLIENT_BLT)
+ | BLT_BR00_OP(BLT_OP_XY_SETUP_BLT)
+ | BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB)
+ | BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DWORD_LENGTH(GEN(batch, 8) ? 8 : 6),
+
+ BLT_BR01_CLIPPING_ENABLE(false)
+ | BLT_BR01_MONO_SRC_TRANSPARENCY(monochrome_source_transparency)
+ | BLT_BR01_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT)
+ | BLT_BR01_RASTER_OPERATION(raster_operation)
+ | BLT_BR01_DST_PITCH(tiling_mode == I915_TILING_NONE
+ ? dst_pitch : dst_pitch >> 2),
+
+ /* XXX: No clipping yet */
+ BLT_BR24_CLP_Y1(0)
+ | BLT_BR24_CLP_X1(0),
+
+ BLT_BR25_CLP_Y2(0)
+ | BLT_BR25_CLP_X2(0)
+ );
+
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR09_DST_ADDRESS(dst->offset64),
+ /* if gen8 */
+ BLT_BR27_DST_ADDRESS_HI(dst->offset64 >> 32)
+ );
+
+ intel_batch_add_dwords(batch, 2,
+ BLT_BR05_BACKGROUND_COLOR(background_color),
+ BLT_BR06_FOREGROUND_COLOR(foreground_color)
+ );
+
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR07_PAT_ADDRESS(0),
+ /* if gen8 */
+ BLT_BR30_PAT_ADDRESS_HI(0)
+ );
}
-static inline int xy_text_blt(struct intel_batch *batch, drm_intel_bo *src,
- uint32_t src_offset, drm_intel_bo *dst,
- int16_t dst_x1, int16_t dst_y1, int16_t dst_x2,
- int16_t dst_y2) {
- uint32_t tiling_mode, swizzle_mode;
-
- if (!intel_batch_check_space(batch, 4))
- return INTEL_BATCH_NO_SPACE;
-
- drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
-
- drm_intel_bo_emit_reloc_fence(batch->bo, intel_batch_offset(batch, 3), src,
- src_offset, I915_GEM_DOMAIN_RENDER, 0);
-
- intel_batch_add_dwords(
- batch, 4,
- BLT_BR00_CLIENT(INTEL_CLIENT_BLT) | BLT_BR00_OP(BLT_OP_XY_TEXT_BLT) |
- BLT_BR00_PACKING(BLT_PACKING_BYTE) |
- BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DWORD_LENGTH(2),
-
- BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
- BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2),
- BLT_BR12_SRC_ADDRESS(src->offset + src_offset));
-
- return INTEL_BATCH_SUCCESS;
+static inline int xy_text_blt(struct intel_batch * batch,
+ drm_intel_bo * src, uint32_t src_offset,
+ drm_intel_bo * dst,
+ int16_t dst_x1, int16_t dst_y1,
+ int16_t dst_x2, int16_t dst_y2)
+{
+ uint32_t tiling_mode, swizzle_mode;
+
+ if (!intel_batch_check_space(batch, GEN(batch, 8) ? 5 : 4))
+ return INTEL_BATCH_NO_SPACE;
+
+ drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
+
+ drm_intel_bo_emit_reloc_fence
+ (batch->bo, intel_batch_offset(batch, 3), src, src_offset,
+ I915_GEM_DOMAIN_RENDER, 0);
+
+ intel_batch_add_dwords(batch, 3,
+ BLT_BR00_CLIENT(INTEL_CLIENT_BLT)
+ | BLT_BR00_OP(BLT_OP_XY_TEXT_BLT)
+ | BLT_BR00_PACKING(BLT_PACKING_BYTE)
+ | BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DWORD_LENGTH(GEN(batch, 8) ? 3 : 2),
+
+ BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
+ BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2)
+ );
+
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR12_SRC_ADDRESS(src->offset64 + src_offset),
+ /* if gen8 */
+ BLT_BR28_SRC_ADDRESS_HI((src->offset64 + src_offset) >> 32)
+ );
+
+ return INTEL_BATCH_SUCCESS;
}
-static inline int xy_text_immediate_blt(struct intel_batch *batch,
- drm_intel_bo *dst, int16_t dst_x1,
- int16_t dst_y1, int16_t dst_x2,
- int16_t dst_y2, uint16_t count,
- uint32_t *immediates) {
- /* Round up to the next even number. */
- uint8_t dwords = (count + 1) & ~1;
- uint32_t index;
- uint32_t tiling_mode, swizzle_mode;
-
- if (!intel_batch_check_space(batch, 3 + dwords))
- return INTEL_BATCH_NO_SPACE;
-
- drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
-
- intel_batch_add_dwords(
- batch, 3,
- BLT_BR00_CLIENT(INTEL_CLIENT_BLT) |
- BLT_BR00_OP(BLT_OP_XY_TEXT_IMMEDIATE_BLT) |
- BLT_BR00_PACKING(BLT_PACKING_BYTE) |
- BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DWORD_LENGTH(1 + dwords),
-
- BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
- BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2));
-
- for (index = 0; index < count; ++index)
- intel_batch_add_dword(batch, *immediates++);
-
- /* From BLT engine documentation:
- *
- * The IMMEDIATE_BLT data MUST transfer an even number of doublewords. The
- * BLT engine will hang if it does not get an even number of doublewords. */
- if (count & 1)
- intel_batch_add_dword(batch, 0);
-
- return INTEL_BATCH_SUCCESS;
+static inline int xy_text_immediate_blt(struct intel_batch * batch,
+ drm_intel_bo * dst,
+ int16_t dst_x1, int16_t dst_y1,
+ int16_t dst_x2, int16_t dst_y2,
+ uint16_t count, uint32_t * immediates)
+{
+ /* Round up to the next even number. */
+ uint8_t dwords = (count + 1) & ~1;
+ uint32_t index;
+ uint32_t tiling_mode, swizzle_mode;
+
+ if (!intel_batch_check_space(batch, 3 + dwords))
+ return INTEL_BATCH_NO_SPACE;
+
+ drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
+
+ intel_batch_add_dwords(batch, 3,
+ BLT_BR00_CLIENT(INTEL_CLIENT_BLT)
+ | BLT_BR00_OP(BLT_OP_XY_TEXT_IMMEDIATE_BLT)
+ | BLT_BR00_PACKING(BLT_PACKING_BYTE)
+ | BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DWORD_LENGTH(1 + dwords),
+
+ BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
+ BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2)
+ );
+
+ for (index = 0; index < count; ++index)
+ intel_batch_add_dword(batch, *immediates++);
+
+ /* From BLT engine documentation:
+ *
+ * The IMMEDIATE_BLT data MUST transfer an even number of doublewords. The
+ * BLT engine will hang if it does not get an even number of doublewords. */
+ if (count & 1)
+ intel_batch_add_dword(batch, 0);
+
+ return INTEL_BATCH_SUCCESS;
}
-static inline void xy_src_copy_blt(struct intel_batch *batch, drm_intel_bo *src,
- uint16_t src_pitch, uint16_t src_x,
- uint16_t src_y, drm_intel_bo *dst,
- uint16_t dst_pitch, uint16_t dst_x,
- uint16_t dst_y, uint16_t width,
- uint16_t height) {
- uint32_t src_tiling_mode, dst_tiling_mode, swizzle;
-
- intel_batch_ensure_space(batch, 8);
-
- drm_intel_bo_get_tiling(dst, &dst_tiling_mode, &swizzle);
- drm_intel_bo_get_tiling(src, &src_tiling_mode, &swizzle);
-
- drm_intel_bo_emit_reloc_fence(batch->bo, intel_batch_offset(batch, 4), dst, 0,
- I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
- drm_intel_bo_emit_reloc_fence(batch->bo, intel_batch_offset(batch, 7), src, 0,
- I915_GEM_DOMAIN_RENDER, 0);
-
- intel_batch_add_dwords(
- batch, 8,
- BLT_BR00_CLIENT(INTEL_CLIENT_BLT) | BLT_BR00_OP(BLT_OP_XY_SRC_COPY_BLT) |
- BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB) |
- BLT_BR00_SRC_TILING_ENABLE(src_tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DST_TILING_ENABLE(dst_tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DWORD_LENGTH(6),
-
- BLT_BR13_CLIPPING_ENABLE(false) |
- BLT_BR13_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT) |
- BLT_BR13_RASTER_OPERATION(BLT_RASTER_OPERATION_SRC) |
- BLT_BR13_DST_PITCH(
- dst_tiling_mode == I915_TILING_NONE ? dst_pitch : dst_pitch >> 2),
-
- BLT_BR22_DST_Y1(dst_y) | BLT_BR22_DST_X1(dst_x),
-
- BLT_BR23_DST_Y2(dst_y + height) | BLT_BR23_DST_X2(dst_x + width),
-
- BLT_BR09_DST_ADDRESS(dst->offset),
- BLT_BR26_SRC_Y1(src_y) | BLT_BR26_SRC_X1(src_x),
- BLT_BR11_SRC_PITCH(src_tiling_mode == I915_TILING_NONE ? src_pitch
- : src_pitch >> 2),
- BLT_BR12_SRC_ADDRESS(src->offset));
+static inline void xy_src_copy_blt(struct intel_batch * batch,
+ drm_intel_bo * src, uint16_t src_pitch,
+ uint16_t src_x, uint16_t src_y,
+ drm_intel_bo * dst, uint16_t dst_pitch,
+ uint16_t dst_x, uint16_t dst_y,
+ uint16_t width, uint16_t height)
+{
+ uint32_t src_tiling_mode, dst_tiling_mode, swizzle;
+
+ intel_batch_ensure_space(batch, GEN(batch, 8) ? 10 : 8);
+
+ drm_intel_bo_get_tiling(dst, &dst_tiling_mode, &swizzle);
+ drm_intel_bo_get_tiling(src, &src_tiling_mode, &swizzle);
+
+ drm_intel_bo_emit_reloc_fence
+ (batch->bo, intel_batch_offset(batch, 4), dst, 0,
+ I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
+ drm_intel_bo_emit_reloc_fence
+ (batch->bo, intel_batch_offset(batch, GEN(batch, 8) ? 8 : 7), src, 0,
+ I915_GEM_DOMAIN_RENDER, 0);
+
+ intel_batch_add_dwords(batch, 4,
+ BLT_BR00_CLIENT(INTEL_CLIENT_BLT)
+ | BLT_BR00_OP(BLT_OP_XY_SRC_COPY_BLT)
+ | BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB)
+ | BLT_BR00_SRC_TILING_ENABLE(src_tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DST_TILING_ENABLE(dst_tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DWORD_LENGTH(GEN(batch, 8) ? 8 : 6),
+
+ BLT_BR13_CLIPPING_ENABLE(false)
+ | BLT_BR13_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT)
+ | BLT_BR13_RASTER_OPERATION(BLT_RASTER_OPERATION_SRC)
+ | BLT_BR13_DST_PITCH(dst_tiling_mode == I915_TILING_NONE
+ ? dst_pitch : dst_pitch >> 2),
+
+ BLT_BR22_DST_Y1(dst_y) | BLT_BR22_DST_X1(dst_x),
+
+ BLT_BR23_DST_Y2(dst_y + height)
+ | BLT_BR23_DST_X2(dst_x + width)
+ );
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR09_DST_ADDRESS(dst->offset64),
+ BLT_BR27_DST_ADDRESS_HI(dst->offset64 >> 32)
+ );
+ intel_batch_add_dwords(batch, 2,
+ BLT_BR26_SRC_Y1(src_y) | BLT_BR26_SRC_X1(src_x),
+ BLT_BR11_SRC_PITCH(src_tiling_mode == I915_TILING_NONE
+ ? src_pitch : src_pitch >> 2)
+ );
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR12_SRC_ADDRESS(src->offset64),
+ BLT_BR28_SRC_ADDRESS_HI(src->offset64 >> 32)
+ );
}
-static inline void xy_color_blt(struct intel_batch *batch, drm_intel_bo *dst,
- uint16_t dst_pitch, uint16_t dst_x1,
- uint16_t dst_y1, uint16_t dst_x2,
- uint16_t dst_y2, uint32_t color) {
- uint32_t tiling_mode, swizzle_mode;
-
- intel_batch_ensure_space(batch, 6);
-
- drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
-
- drm_intel_bo_emit_reloc_fence(batch->bo, intel_batch_offset(batch, 4), dst, 0,
- I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
-
- intel_batch_add_dwords(
- batch, 6,
- BLT_BR00_CLIENT(INTEL_CLIENT_BLT) | BLT_BR00_OP(BLT_OP_XY_COLOR_BLT) |
- BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB) |
- BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE) |
- BLT_BR00_DWORD_LENGTH(4),
-
- BLT_BR13_CLIPPING_ENABLE(false) |
- BLT_BR13_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT) |
- BLT_BR13_RASTER_OPERATION(BLT_RASTER_OPERATION_PAT) |
- BLT_BR13_DST_PITCH(tiling_mode == I915_TILING_NONE ? dst_pitch
- : dst_pitch >> 2),
-
- BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
- BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2),
- BLT_BR09_DST_ADDRESS(dst->offset), BLT_BR16_COLOR(color));
+static inline void xy_color_blt(struct intel_batch * batch,
+ drm_intel_bo * dst, uint16_t dst_pitch,
+ uint16_t dst_x1, uint16_t dst_y1,
+ uint16_t dst_x2, uint16_t dst_y2,
+ uint32_t color)
+{
+ uint32_t tiling_mode, swizzle_mode;
+
+ intel_batch_ensure_space(batch, GEN(batch, 8) ? 7 : 6);
+
+ drm_intel_bo_get_tiling(dst, &tiling_mode, &swizzle_mode);
+
+ drm_intel_bo_emit_reloc_fence
+ (batch->bo, intel_batch_offset(batch, 4), dst, 0,
+ I915_GEM_DOMAIN_RENDER, I915_GEM_DOMAIN_RENDER);
+
+ intel_batch_add_dwords(batch, 4,
+ BLT_BR00_CLIENT(INTEL_CLIENT_BLT)
+ | BLT_BR00_OP(BLT_OP_XY_COLOR_BLT)
+ | BLT_BR00_32BPP_MASK(BLT_32BPP_MASK_ALPHA | BLT_32BPP_MASK_RGB)
+ | BLT_BR00_DST_TILING_ENABLE(tiling_mode != I915_TILING_NONE)
+ | BLT_BR00_DWORD_LENGTH(GEN(batch, 8) ? 5 : 4),
+
+ BLT_BR13_CLIPPING_ENABLE(false)
+ | BLT_BR13_COLOR_DEPTH(BLT_COLOR_DEPTH_32BIT)
+ | BLT_BR13_RASTER_OPERATION(BLT_RASTER_OPERATION_PAT)
+ | BLT_BR13_DST_PITCH(tiling_mode == I915_TILING_NONE
+ ? dst_pitch : dst_pitch >> 2),
+
+ BLT_BR22_DST_Y1(dst_y1) | BLT_BR22_DST_X1(dst_x1),
+ BLT_BR23_DST_Y2(dst_y2) | BLT_BR23_DST_X2(dst_x2)
+ );
+ intel_batch_add_dwords(batch, GEN(batch, 8) ? 2 : 1,
+ BLT_BR09_DST_ADDRESS(dst->offset64),
+ BLT_BR27_DST_ADDRESS_HI(dst->offset64 >> 32)
+ );
+ intel_batch_add_dword(batch,
+ BLT_BR16_COLOR(color)
+ );
}
#endif
+
diff --git a/src/wld/intel/i965_pci_ids.h b/src/wld/intel/i965_pci_ids.h
index 6126cce..57e70b7 100644
--- a/src/wld/intel/i965_pci_ids.h
+++ b/src/wld/intel/i965_pci_ids.h
@@ -1,18 +1,18 @@
-CHIPSET(0x29A2, i965, "Intel(R) 965G")
-CHIPSET(0x2992, i965, "Intel(R) 965Q")
-CHIPSET(0x2982, i965, "Intel(R) 965G")
-CHIPSET(0x2972, i965, "Intel(R) 946GZ")
-CHIPSET(0x2A02, i965, "Intel(R) 965GM")
-CHIPSET(0x2A12, i965, "Intel(R) 965GME/GLE")
-CHIPSET(0x2A42, g4x, "Mobile IntelĀ® GM45 Express Chipset")
-CHIPSET(0x2E02, g4x, "Intel(R) Integrated Graphics Device")
-CHIPSET(0x2E12, g4x, "Intel(R) Q45/Q43")
-CHIPSET(0x2E22, g4x, "Intel(R) G45/G43")
-CHIPSET(0x2E32, g4x, "Intel(R) G41")
-CHIPSET(0x2E42, g4x, "Intel(R) B43")
-CHIPSET(0x2E92, g4x, "Intel(R) B43")
-CHIPSET(0x0042, ilk, "Intel(R) Ironlake Desktop")
-CHIPSET(0x0046, ilk, "Intel(R) Ironlake Mobile")
+CHIPSET(0x29A2, i965, "Intel(R) 965G")
+CHIPSET(0x2992, i965, "Intel(R) 965Q")
+CHIPSET(0x2982, i965, "Intel(R) 965G")
+CHIPSET(0x2972, i965, "Intel(R) 946GZ")
+CHIPSET(0x2A02, i965, "Intel(R) 965GM")
+CHIPSET(0x2A12, i965, "Intel(R) 965GME/GLE")
+CHIPSET(0x2A42, g4x, "Mobile IntelĀ® GM45 Express Chipset")
+CHIPSET(0x2E02, g4x, "Intel(R) Integrated Graphics Device")
+CHIPSET(0x2E12, g4x, "Intel(R) Q45/Q43")
+CHIPSET(0x2E22, g4x, "Intel(R) G45/G43")
+CHIPSET(0x2E32, g4x, "Intel(R) G41")
+CHIPSET(0x2E42, g4x, "Intel(R) B43")
+CHIPSET(0x2E92, g4x, "Intel(R) B43")
+CHIPSET(0x0042, ilk, "Intel(R) Ironlake Desktop")
+CHIPSET(0x0046, ilk, "Intel(R) Ironlake Mobile")
CHIPSET(0x0102, snb_gt1, "Intel(R) Sandybridge Desktop")
CHIPSET(0x0112, snb_gt2, "Intel(R) Sandybridge Desktop")
CHIPSET(0x0122, snb_gt2, "Intel(R) Sandybridge Desktop")
@@ -86,8 +86,105 @@ CHIPSET(0x0D2B, hsw_gt3, "Intel(R) Haswell")
CHIPSET(0x0D0E, hsw_gt1, "Intel(R) Haswell")
CHIPSET(0x0D1E, hsw_gt2, "Intel(R) Haswell")
CHIPSET(0x0D2E, hsw_gt3, "Intel(R) Haswell")
-CHIPSET(0x0F31, byt, "Intel(R) Bay Trail")
-CHIPSET(0x0F32, byt, "Intel(R) Bay Trail")
-CHIPSET(0x0F33, byt, "Intel(R) Bay Trail")
-CHIPSET(0x0157, byt, "Intel(R) Bay Trail")
-CHIPSET(0x0155, byt, "Intel(R) Bay Trail")
+CHIPSET(0x0F31, byt, "Intel(R) Bay Trail")
+CHIPSET(0x0F32, byt, "Intel(R) Bay Trail")
+CHIPSET(0x0F33, byt, "Intel(R) Bay Trail")
+CHIPSET(0x0157, byt, "Intel(R) Bay Trail")
+CHIPSET(0x0155, byt, "Intel(R) Bay Trail")
+CHIPSET(0x1602, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x1606, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x160A, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x160B, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x160D, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x160E, bdw_gt1, "Intel(R) Broadwell GT1")
+CHIPSET(0x1612, bdw_gt2, "Intel(R) HD Graphics 5600 (Broadwell GT2)")
+CHIPSET(0x1616, bdw_gt2, "Intel(R) HD Graphics 5500 (Broadwell GT2)")
+CHIPSET(0x161A, bdw_gt2, "Intel(R) Broadwell GT2")
+CHIPSET(0x161B, bdw_gt2, "Intel(R) Broadwell GT2")
+CHIPSET(0x161D, bdw_gt2, "Intel(R) Broadwell GT2")
+CHIPSET(0x161E, bdw_gt2, "Intel(R) HD Graphics 5300 (Broadwell GT2)")
+CHIPSET(0x1622, bdw_gt3, "Intel(R) Iris Pro 6200 (Broadwell GT3e)")
+CHIPSET(0x1626, bdw_gt3, "Intel(R) HD Graphics 6000 (Broadwell GT3)")
+CHIPSET(0x162A, bdw_gt3, "Intel(R) Iris Pro P6300 (Broadwell GT3e)")
+CHIPSET(0x162B, bdw_gt3, "Intel(R) Iris 6100 (Broadwell GT3)")
+CHIPSET(0x162D, bdw_gt3, "Intel(R) Broadwell GT3")
+CHIPSET(0x162E, bdw_gt3, "Intel(R) Broadwell GT3")
+CHIPSET(0x22B0, chv, "Intel(R) HD Graphics (Cherrytrail)")
+CHIPSET(0x22B1, chv, "Intel(R) HD Graphics XXX (Braswell)") /* Overridden in brw_get_renderer_string */
+CHIPSET(0x22B2, chv, "Intel(R) HD Graphics (Cherryview)")
+CHIPSET(0x22B3, chv, "Intel(R) HD Graphics (Cherryview)")
+CHIPSET(0x1902, skl_gt1, "Intel(R) HD Graphics 510 (Skylake GT1)")
+CHIPSET(0x1906, skl_gt1, "Intel(R) HD Graphics 510 (Skylake GT1)")
+CHIPSET(0x190A, skl_gt1, "Intel(R) Skylake GT1")
+CHIPSET(0x190B, skl_gt1, "Intel(R) HD Graphics 510 (Skylake GT1)")
+CHIPSET(0x190E, skl_gt1, "Intel(R) Skylake GT1")
+CHIPSET(0x1912, skl_gt2, "Intel(R) HD Graphics 530 (Skylake GT2)")
+CHIPSET(0x1913, skl_gt2, "Intel(R) Skylake GT2f")
+CHIPSET(0x1915, skl_gt2, "Intel(R) Skylake GT2f")
+CHIPSET(0x1916, skl_gt2, "Intel(R) HD Graphics 520 (Skylake GT2)")
+CHIPSET(0x1917, skl_gt2, "Intel(R) Skylake GT2f")
+CHIPSET(0x191A, skl_gt2, "Intel(R) Skylake GT2")
+CHIPSET(0x191B, skl_gt2, "Intel(R) HD Graphics 530 (Skylake GT2)")
+CHIPSET(0x191D, skl_gt2, "Intel(R) HD Graphics P530 (Skylake GT2)")
+CHIPSET(0x191E, skl_gt2, "Intel(R) HD Graphics 515 (Skylake GT2)")
+CHIPSET(0x1921, skl_gt2, "Intel(R) HD Graphics 520 (Skylake GT2)")
+CHIPSET(0x1923, skl_gt3, "Intel(R) Skylake GT3e")
+CHIPSET(0x1926, skl_gt3, "Intel(R) Iris Graphics 540 (Skylake GT3e)")
+CHIPSET(0x1927, skl_gt3, "Intel(R) Iris Graphics 550 (Skylake GT3e)")
+CHIPSET(0x192A, skl_gt4, "Intel(R) Skylake GT4")
+CHIPSET(0x192B, skl_gt3, "Intel(R) Iris Graphics 555 (Skylake GT3e)")
+CHIPSET(0x192D, skl_gt3, "Intel(R) Iris Graphics P555 (Skylake GT3e)")
+CHIPSET(0x1932, skl_gt4, "Intel(R) Iris Pro Graphics 580 (Skylake GT4e)")
+CHIPSET(0x193A, skl_gt4, "Intel(R) Iris Pro Graphics P580 (Skylake GT4e)")
+CHIPSET(0x193B, skl_gt4, "Intel(R) Iris Pro Graphics 580 (Skylake GT4e)")
+CHIPSET(0x193D, skl_gt4, "Intel(R) Iris Pro Graphics P580 (Skylake GT4e)")
+CHIPSET(0x0A84, bxt, "Intel(R) HD Graphics (Broxton)")
+CHIPSET(0x1A84, bxt, "Intel(R) HD Graphics (Broxton)")
+CHIPSET(0x1A85, bxt_2x6, "Intel(R) HD Graphics (Broxton 2x6)")
+CHIPSET(0x5A84, bxt, "Intel(R) HD Graphics 505 (Broxton)")
+CHIPSET(0x5A85, bxt_2x6, "Intel(R) HD Graphics 500 (Broxton 2x6)")
+CHIPSET(0x5902, kbl_gt1, "Intel(R) HD Graphics 610 (Kaby Lake GT1)")
+CHIPSET(0x5906, kbl_gt1, "Intel(R) HD Graphics 610 (Kaby Lake GT1)")
+CHIPSET(0x590A, kbl_gt1, "Intel(R) Kabylake GT1")
+CHIPSET(0x5908, kbl_gt1, "Intel(R) Kabylake GT1")
+CHIPSET(0x590B, kbl_gt1, "Intel(R) Kabylake GT1")
+CHIPSET(0x590E, kbl_gt1, "Intel(R) Kabylake GT1")
+CHIPSET(0x5913, kbl_gt1_5, "Intel(R) Kabylake GT1.5")
+CHIPSET(0x5915, kbl_gt1_5, "Intel(R) Kabylake GT1.5")
+CHIPSET(0x5917, kbl_gt1_5, "Intel(R) Kabylake GT1.5")
+CHIPSET(0x5912, kbl_gt2, "Intel(R) HD Graphics 630 (Kaby Lake GT2)")
+CHIPSET(0x5916, kbl_gt2, "Intel(R) HD Graphics 620 (Kaby Lake GT2)")
+CHIPSET(0x591A, kbl_gt2, "Intel(R) HD Graphics P630 (Kaby Lake GT2)")
+CHIPSET(0x591B, kbl_gt2, "Intel(R) HD Graphics 630 (Kaby Lake GT2)")
+CHIPSET(0x591D, kbl_gt2, "Intel(R) HD Graphics P630 (Kaby Lake GT2)")
+CHIPSET(0x591E, kbl_gt2, "Intel(R) HD Graphics 615 (Kaby Lake GT2)")
+CHIPSET(0x5921, kbl_gt2, "Intel(R) Kabylake GT2F")
+CHIPSET(0x5923, kbl_gt3, "Intel(R) Kabylake GT3")
+CHIPSET(0x5926, kbl_gt3, "Intel(R) Iris Plus Graphics 640 (Kaby Lake GT3)")
+CHIPSET(0x5927, kbl_gt3, "Intel(R) Iris Plus Graphics 650 (Kaby Lake GT3)")
+CHIPSET(0x593B, kbl_gt4, "Intel(R) Kabylake GT4")
+CHIPSET(0x3184, glk, "Intel(R) HD Graphics (Geminilake)")
+CHIPSET(0x3185, glk_2x6, "Intel(R) HD Graphics (Geminilake 2x6)")
+CHIPSET(0x3E90, cfl_gt1, "Intel(R) HD Graphics (Coffeelake 2x6 GT1)")
+CHIPSET(0x3E93, cfl_gt1, "Intel(R) HD Graphics (Coffeelake 2x6 GT1)")
+CHIPSET(0x3E91, cfl_gt2, "Intel(R) HD Graphics (Coffeelake 3x8 GT2)")
+CHIPSET(0x3E92, cfl_gt2, "Intel(R) HD Graphics (Coffeelake 3x8 GT2)")
+CHIPSET(0x3E96, cfl_gt2, "Intel(R) HD Graphics (Coffeelake 3x8 GT2)")
+CHIPSET(0x3E9B, cfl_gt2, "Intel(R) HD Graphics (Coffeelake 3x8 GT2)")
+CHIPSET(0x3E94, cfl_gt2, "Intel(R) HD Graphics (Coffeelake 3x8 GT2)")
+CHIPSET(0x3EA6, cfl_gt3, "Intel(R) HD Graphics (Coffeelake 3x8 GT3)")
+CHIPSET(0x3EA7, cfl_gt3, "Intel(R) HD Graphics (Coffeelake 3x8 GT3)")
+CHIPSET(0x3EA8, cfl_gt3, "Intel(R) HD Graphics (Coffeelake 3x8 GT3)")
+CHIPSET(0x3EA5, cfl_gt3, "Intel(R) HD Graphics (Coffeelake 3x8 GT3)")
+CHIPSET(0x5A49, cnl_2x8, "Intel(R) HD Graphics (Cannonlake 2x8 GT0.5)")
+CHIPSET(0x5A4A, cnl_2x8, "Intel(R) HD Graphics (Cannonlake 2x8 GT0.5)")
+CHIPSET(0x5A41, cnl_3x8, "Intel(R) HD Graphics (Cannonlake 3x8 GT1)")
+CHIPSET(0x5A42, cnl_3x8, "Intel(R) HD Graphics (Cannonlake 3x8 GT1)")
+CHIPSET(0x5A44, cnl_3x8, "Intel(R) HD Graphics (Cannonlake 3x8 GT1)")
+CHIPSET(0x5A59, cnl_4x8, "Intel(R) HD Graphics (Cannonlake 4x8 GT1.5)")
+CHIPSET(0x5A5A, cnl_4x8, "Intel(R) HD Graphics (Cannonlake 4x8 GT1.5)")
+CHIPSET(0x5A5C, cnl_4x8, "Intel(R) HD Graphics (Cannonlake 4x8 GT1.5)")
+CHIPSET(0x5A50, cnl_5x8, "Intel(R) HD Graphics (Cannonlake 5x8 GT2)")
+CHIPSET(0x5A51, cnl_5x8, "Intel(R) HD Graphics (Cannonlake 5x8 GT2)")
+CHIPSET(0x5A52, cnl_5x8, "Intel(R) HD Graphics (Cannonlake 5x8 GT2)")
+CHIPSET(0x5A54, cnl_5x8, "Intel(R) HD Graphics (Cannonlake 5x8 GT2)")
diff --git a/src/wld/intel/intel.c b/src/wld/intel/intel.c
deleted file mode 100644
index 9e16183..0000000
--- a/src/wld/intel/intel.c
+++ /dev/null
@@ -1,358 +0,0 @@
-/* wld: intel.c
- *
- * Copyright (c) 2013, 2014 Michael Forney
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "batch.h"
-#include "blt.h"
-#include "wld/drm-private.h"
-#include "wld/drm.h"
-#include "wld/wld-private.h"
-
-#include <i915_drm.h>
-#include <intel_bufmgr.h>
-#include <unistd.h>
-
-struct intel_context {
- struct wld_context base;
- drm_intel_bufmgr *bufmgr;
-};
-
-struct intel_renderer {
- struct wld_renderer base;
- struct intel_batch batch;
- struct intel_buffer *target;
-};
-
-struct intel_buffer {
- struct buffer base;
- struct wld_exporter exporter;
- drm_intel_bo *bo;
-};
-
-#include "../interface/buffer.h"
-#include "../interface/context.h"
-#include "../interface/renderer.h"
-#define DRM_DRIVER_NAME intel
-#include "../interface/drm.h"
-IMPL(intel_context, wld_context)
-IMPL(intel_renderer, wld_renderer)
-IMPL(intel_buffer, wld_buffer)
-
-/**** DRM driver ****/
-bool driver_device_supported(uint32_t vendor_id, uint32_t device_id) {
- return vendor_id == 0x8086;
-}
-
-struct wld_context *driver_create_context(int drm_fd) {
- struct intel_context *context;
-
- context = malloc(sizeof *context);
-
- if (!context)
- goto error0;
-
- context_initialize(&context->base, &wld_context_impl);
- context->bufmgr = drm_intel_bufmgr_gem_init(drm_fd, INTEL_BATCH_SIZE);
-
- if (!context->bufmgr)
- goto error1;
-
- return &context->base;
-
-error1:
- free(context);
-error0:
- return NULL;
-}
-
-/**** Context ****/
-struct wld_renderer *context_create_renderer(struct wld_context *base) {
- struct intel_context *context = intel_context(base);
- struct intel_renderer *renderer;
-
- if (!(renderer = malloc(sizeof *renderer)))
- goto error0;
-
- if (!(intel_batch_initialize(&renderer->batch, context->bufmgr)))
- goto error1;
-
- renderer_initialize(&renderer->base, &wld_renderer_impl);
-
- return &renderer->base;
-
-error1:
- free(renderer);
-error0:
- return NULL;
-}
-
-static bool export(struct wld_exporter *exporter, struct wld_buffer *base,
- uint32_t type, union wld_object *object) {
- struct intel_buffer *buffer = intel_buffer(base);
-
- switch (type) {
- case WLD_DRM_OBJECT_HANDLE:
- object->u32 = buffer->bo->handle;
- return true;
- case WLD_DRM_OBJECT_PRIME_FD:
- if (drm_intel_bo_gem_export_to_prime(buffer->bo, &object->i) != 0)
- return false;
- return true;
- default:
- return false;
- }
-}
-
-static struct buffer *new_buffer(uint32_t width, uint32_t height,
- uint32_t format, uint32_t pitch,
- drm_intel_bo *bo) {
- struct intel_buffer *buffer;
-
- if (!(buffer = malloc(sizeof *buffer)))
- return NULL;
-
- buffer_initialize(&buffer->base, &wld_buffer_impl, width, height, format,
- pitch);
- buffer->bo = bo;
- buffer->exporter.export = &export;
- wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
-
- return &buffer->base;
-}
-
-struct buffer *context_create_buffer(struct wld_context *base, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t flags) {
- struct intel_context *context = intel_context(base);
- struct buffer *buffer;
- drm_intel_bo *bo;
- uint32_t tiling_mode = width >= 128 ? I915_TILING_X : I915_TILING_NONE;
- unsigned long pitch;
-
- bo = drm_intel_bo_alloc_tiled(context->bufmgr, "buffer", width, height, 4,
- &tiling_mode, &pitch, 0);
-
- if (!bo)
- goto error0;
-
- if (!(buffer = new_buffer(width, height, format, pitch, bo)))
- goto error1;
-
- return buffer;
-
-error1:
- drm_intel_bo_unreference(bo);
-error0:
- return NULL;
-}
-
-struct buffer *context_import_buffer(struct wld_context *base, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- struct intel_context *context = intel_context(base);
- struct buffer *buffer;
- drm_intel_bo *bo;
-
- switch (type) {
- case WLD_DRM_OBJECT_PRIME_FD: {
- uint32_t size = width * height * format_bytes_per_pixel(format);
- bo = drm_intel_bo_gem_create_from_prime(context->bufmgr, object.i, size);
- break;
- }
- default:
- bo = NULL;
- };
-
- if (!bo)
- goto error0;
-
- if (!(buffer = new_buffer(width, height, format, pitch, bo)))
- goto error1;
-
- return buffer;
-
-error1:
- drm_intel_bo_unreference(bo);
-error0:
- return NULL;
-}
-
-void context_destroy(struct wld_context *base) {
- struct intel_context *context = intel_context(base);
-
- drm_intel_bufmgr_destroy(context->bufmgr);
- free(context);
-}
-
-/**** Renderer ****/
-uint32_t renderer_capabilities(struct wld_renderer *renderer,
- struct buffer *buffer) {
- if (buffer->base.impl == &wld_buffer_impl)
- return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
-
- return 0;
-}
-
-bool renderer_set_target(struct wld_renderer *base, struct buffer *buffer) {
- struct intel_renderer *renderer = intel_renderer(base);
-
- if (buffer && buffer->base.impl != &wld_buffer_impl)
- return false;
-
- renderer->target = buffer ? intel_buffer(&buffer->base) : NULL;
-
- return true;
-}
-
-void renderer_fill_rectangle(struct wld_renderer *base, uint32_t color,
- int32_t x, int32_t y, uint32_t width,
- uint32_t height) {
- struct intel_renderer *renderer = intel_renderer(base);
- struct intel_buffer *dst = renderer->target;
-
- xy_color_blt(&renderer->batch, dst->bo, dst->base.base.pitch, x, y, x + width,
- y + height, color);
-}
-
-void renderer_copy_rectangle(struct wld_renderer *base,
- struct buffer *buffer_base, int32_t dst_x,
- int32_t dst_y, int32_t src_x, int32_t src_y,
- uint32_t width, uint32_t height) {
- struct intel_renderer *renderer = intel_renderer(base);
-
- if (buffer_base->base.impl != &wld_buffer_impl)
- return;
-
- struct intel_buffer *src = intel_buffer(&buffer_base->base),
- *dst = renderer->target;
-
- xy_src_copy_blt(&renderer->batch, src->bo, src->base.base.pitch, src_x, src_y,
- dst->bo, dst->base.base.pitch, dst_x, dst_y, width, height);
-}
-
-void renderer_draw_text(struct wld_renderer *base, struct font *font,
- uint32_t color, int32_t x, int32_t y, const char *text,
- uint32_t length, struct wld_extents *extents) {
- struct intel_renderer *renderer = intel_renderer(base);
- struct intel_buffer *dst = renderer->target;
- int ret;
- struct glyph *glyph;
- uint32_t row;
- FT_UInt glyph_index;
- uint32_t c;
- uint8_t immediate[512];
- uint8_t *byte;
- int32_t origin_x = x;
-
- xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC, 0, color,
- dst->bo, dst->base.base.pitch);
-
- if (length == -1)
- length = strlen(text);
-
- while ((ret = FcUtf8ToUcs4((FcChar8 *)text, &c, length)) > 0 && c != '\0') {
- text += ret;
- length -= ret;
- glyph_index = FT_Get_Char_Index(font->face, c);
-
- if (!font_ensure_glyph(font, glyph_index))
- continue;
-
- glyph = font->glyphs[glyph_index];
-
- if (glyph->bitmap.width == 0 || glyph->bitmap.rows == 0)
- goto advance;
-
- byte = immediate;
-
- /* XY_TEXT_IMMEDIATE requires a pitch with no extra bytes */
- for (row = 0; row < glyph->bitmap.rows; ++row) {
- memcpy(byte, glyph->bitmap.buffer + (row * glyph->bitmap.pitch),
- (glyph->bitmap.width + 7) / 8);
- byte += (glyph->bitmap.width + 7) / 8;
- }
-
- retry:
- ret = xy_text_immediate_blt(
- &renderer->batch, dst->bo, origin_x + glyph->x, y + glyph->y,
- origin_x + glyph->x + glyph->bitmap.width,
- y + glyph->y + glyph->bitmap.rows, (byte - immediate + 3) / 4,
- (uint32_t *)immediate);
-
- if (ret == INTEL_BATCH_NO_SPACE) {
- intel_batch_flush(&renderer->batch);
- xy_setup_blt(&renderer->batch, true, BLT_RASTER_OPERATION_SRC, 0, color,
- dst->bo, dst->base.base.pitch);
- goto retry;
- }
-
- advance:
- origin_x += glyph->advance;
- }
-
- if (extents)
- extents->advance = origin_x - x;
-}
-
-void renderer_flush(struct wld_renderer *base) {
- struct intel_renderer *renderer = intel_renderer(base);
-
- intel_batch_flush(&renderer->batch);
-}
-
-void renderer_destroy(struct wld_renderer *base) {
- struct intel_renderer *renderer = intel_renderer(base);
-
- intel_batch_finalize(&renderer->batch);
- free(renderer);
-}
-
-/**** Buffer ****/
-bool buffer_map(struct buffer *base) {
- struct intel_buffer *buffer = intel_buffer(&base->base);
-
- if (drm_intel_gem_bo_map_gtt(buffer->bo) != 0)
- return false;
-
- buffer->base.base.map = buffer->bo->virtual;
-
- return true;
-}
-
-bool buffer_unmap(struct buffer *base) {
- struct intel_buffer *buffer = intel_buffer(&base->base);
-
- if (drm_intel_gem_bo_unmap_gtt(buffer->bo) != 0)
- return false;
-
- buffer->base.base.map = NULL;
-
- return true;
-}
-
-void buffer_destroy(struct buffer *base) {
- struct intel_buffer *buffer = intel_buffer(&base->base);
-
- drm_intel_bo_unreference(buffer->bo);
- free(buffer);
-}
diff --git a/src/wld/intel/mi.h b/src/wld/intel/mi.h
index da0fcd2..5c830c7 100644
--- a/src/wld/intel/mi.h
+++ b/src/wld/intel/mi.h
@@ -26,24 +26,25 @@
#define INTEL_CLIENT_MI 0x0
-#define MI_OP(opcode) \
- (INTEL_CLIENT_MI << 29 /* 31:29 */ \
- | opcode << 23 /* 28:23 */ \
- )
+#define MI_OP(opcode) ( \
+ INTEL_CLIENT_MI << 29 /* 31:29 */ \
+ | opcode << 23 /* 28:23 */ \
+)
-#define MI_NOOP MI_OP(0x00)
-#define MI_FLUSH MI_OP(0x04)
-#define MI_BATCH_BUFFER_END MI_OP(0x0A)
+#define MI_NOOP MI_OP(0x00)
+#define MI_FLUSH MI_OP(0x04)
+#define MI_BATCH_BUFFER_END MI_OP(0x0A)
/* MI_NOOP */
-#define MI_NOOP_IDENTIFICATION_NUMBER(number) (1 << 22 | number)
+#define MI_NOOP_IDENTIFICATION_NUMBER(number) (1 << 22 | number)
/* MI_FLUSH */
-#define MI_FLUSH_ENABLE_PROTECTED_MEMORY (1 << 6)
-#define MI_FLUSH_DISABLE_INDIRECT_STATE_POINTERS (1 << 5)
-#define MI_FLUSH_CLEAR_GENERIC_MEDIA_STATE (1 << 4)
-#define MI_FLUSH_RESET_GLOBAL_SNAPSHOT_COUNT (1 << 3)
-#define MI_FLUSH_INHIBIT_RENDER_CACHE_FLUSH (1 << 2)
+#define MI_FLUSH_ENABLE_PROTECTED_MEMORY (1 << 6)
+#define MI_FLUSH_DISABLE_INDIRECT_STATE_POINTERS (1 << 5)
+#define MI_FLUSH_CLEAR_GENERIC_MEDIA_STATE (1 << 4)
+#define MI_FLUSH_RESET_GLOBAL_SNAPSHOT_COUNT (1 << 3)
+#define MI_FLUSH_INHIBIT_RENDER_CACHE_FLUSH (1 << 2)
#define MI_FLUSH_INVALIDATE_STATE_INSTRUCTION_CACHE (1 << 1)
#endif
+
diff --git a/src/wld/nouveau.c b/src/wld/nouveau.c
new file mode 100644
index 0000000..306c108
--- /dev/null
+++ b/src/wld/nouveau.c
@@ -0,0 +1,678 @@
+/* wld: nouveau.c
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Based in part upon nvc0_exa.c from xf86-video-nouveau, which is:
+ *
+ * Copyright 2007 NVIDIA, Corporation
+ * Copyright 2008 Ben Skeggs
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#include "drm-private.h"
+#include "drm.h"
+#include "pixman.h"
+#include "nouveau/nv_object.xml.h"
+#include "nouveau/g80_2d.xml.h"
+#include "nouveau/g80_defs.xml.h"
+
+#include <nouveau.h>
+#include <sys/mman.h>
+
+enum nv_architecture
+{
+ NV_ARCH_50 = 0x50,
+ NV_ARCH_C0 = 0xc0,
+ NV_ARCH_E0 = 0xe0
+};
+
+struct nouveau_context
+{
+ struct wld_context base;
+ struct nouveau_device * device;
+ struct nouveau_client * client;
+ enum nv_architecture architecture;
+};
+
+struct nouveau_renderer
+{
+ struct wld_renderer base;
+ struct nouveau_object * channel;
+ struct nouveau_pushbuf * pushbuf;
+ struct nouveau_bufctx * bufctx;
+ struct nouveau_object * nvc0_2d;
+
+ struct nouveau_buffer * target;
+};
+
+struct nouveau_buffer
+{
+ struct buffer base;
+ struct wld_exporter exporter;
+ struct nouveau_context * context;
+ struct nouveau_bo * bo;
+};
+
+#include "interface/context.h"
+#include "interface/renderer.h"
+#include "interface/buffer.h"
+#define DRM_DRIVER_NAME nouveau
+#include "interface/drm.h"
+IMPL(nouveau_context, wld_context)
+IMPL(nouveau_renderer, wld_renderer)
+IMPL(nouveau_buffer, wld_buffer)
+
+/**** DRM driver ****/
+bool driver_device_supported(uint32_t vendor_id, uint32_t device_id)
+{
+ return vendor_id == 0x10de;
+}
+
+struct wld_context * driver_create_context(int drm_fd)
+{
+ struct nouveau_context * context;
+
+ if (!(context = malloc(sizeof *context)))
+ goto error0;
+
+ if (nouveau_device_wrap(drm_fd, 0, &context->device) != 0)
+ goto error1;
+
+ switch (context->device->chipset & ~0xf)
+ {
+ /* TODO: Support NV50
+ case 0x50:
+ case 0x80:
+ case 0x90:
+ case 0xa0:
+ context->architecture = NV_ARCH_50;
+ break;
+ */
+ case 0xc0:
+ case 0xd0:
+ context->architecture = NV_ARCH_C0;
+ break;
+ /* TODO: Support NVE0
+ case 0xe0:
+ case 0xf0:
+ case 0x100:
+ context->architecture = NV_ARCH_E0;
+ break;
+ */
+ default:
+ return NULL;
+ }
+
+ if (nouveau_client_new(context->device, &context->client) != 0)
+ goto error2;
+
+ context_initialize(&context->base, &wld_context_impl);
+
+ return &context->base;
+
+ error2:
+ nouveau_device_del(&context->device);
+ error1:
+ free(context);
+ error0:
+ return NULL;
+}
+
+/**** Context ****/
+static inline bool ensure_space(struct nouveau_pushbuf * push, uint32_t count)
+{
+ if (push->end - push->cur > count)
+ return true;
+
+ return nouveau_pushbuf_space(push, count, 0, 0) == 0;
+}
+
+static inline void nv_add_dword(struct nouveau_pushbuf * push, uint32_t dword)
+{
+ *push->cur++ = dword;
+}
+
+static inline void nv_add_dwords_va(struct nouveau_pushbuf * push,
+ uint16_t count, va_list dwords)
+{
+ while (count--)
+ nv_add_dword(push, va_arg(dwords, uint32_t));
+}
+
+static inline void nv_add_data(struct nouveau_pushbuf * push,
+ void * data, uint32_t count)
+{
+ memcpy(push->cur, data, count * 4);
+ push->cur += count;
+}
+
+static inline uint32_t nvc0_format(uint32_t format)
+{
+ switch (format)
+ {
+ case WLD_FORMAT_XRGB8888:
+ return G80_SURFACE_FORMAT_BGRX8_UNORM;
+ case WLD_FORMAT_ARGB8888:
+ return G80_SURFACE_FORMAT_BGRA8_UNORM;
+ }
+
+ return 0;
+}
+
+enum
+{
+ GF100_COMMAND_TYPE_INCREASING = 1,
+ GF100_COMMAND_TYPE_NON_INCREASING = 3,
+ GF100_COMMAND_TYPE_INLINE = 4
+};
+
+enum
+{
+ GF100_SUBCHANNEL_2D = 3,
+};
+
+static inline uint32_t nvc0_command(uint8_t type, uint8_t subchannel,
+ uint16_t method, uint16_t count_or_value)
+{
+ return type << 29 | count_or_value << 16 | subchannel << 13 | method >> 2;
+}
+
+static inline void nvc0_inline(struct nouveau_pushbuf * push,
+ uint8_t subchannel, uint16_t method,
+ uint16_t value)
+{
+ nv_add_dword(push, nvc0_command(GF100_COMMAND_TYPE_INLINE,
+ subchannel, method, value));
+}
+
+static inline void nvc0_methods(struct nouveau_pushbuf * push,
+ uint8_t subchannel, uint16_t start_method,
+ uint16_t count, ...)
+{
+ va_list dwords;
+ nv_add_dword(push, nvc0_command(GF100_COMMAND_TYPE_INCREASING,
+ subchannel, start_method, count));
+ va_start(dwords, count);
+ nv_add_dwords_va(push, count, dwords);
+ va_end(dwords);
+}
+
+#define nvc0_2d(push, method, count, ...) \
+ nvc0_methods(push, GF100_SUBCHANNEL_2D, method, count, __VA_ARGS__)
+#define nvc0_2d_inline(push, method, value) \
+ nvc0_inline(push, GF100_SUBCHANNEL_2D, method, value)
+
+static bool nvc0_2d_initialize(struct nouveau_renderer * renderer)
+{
+ int ret;
+
+ ret = nouveau_object_new(renderer->channel, GF100_2D, GF100_2D, NULL, 0,
+ &renderer->nvc0_2d);
+
+ if (ret != 0)
+ goto error0;
+
+ if (!ensure_space(renderer->pushbuf, 5))
+ goto error1;
+
+ nvc0_2d(renderer->pushbuf, NV1_SUBCHAN_OBJECT, 1,
+ renderer->nvc0_2d->handle);
+ nvc0_2d_inline(renderer->pushbuf, G80_2D_OPERATION,
+ G80_2D_OPERATION_SRCCOPY_AND);
+ nvc0_2d_inline(renderer->pushbuf, G80_2D_UNK0884, 0x3f);
+ nvc0_2d_inline(renderer->pushbuf, G80_2D_UNK0888, 1);
+
+ return true;
+
+ error1:
+ nouveau_object_del(&renderer->nvc0_2d);
+ error0:
+ return false;
+}
+
+static void nvc0_2d_finalize(struct nouveau_renderer * renderer)
+{
+ nouveau_object_del(&renderer->nvc0_2d);
+}
+
+struct wld_renderer * context_create_renderer(struct wld_context * base)
+{
+ struct nouveau_context * context = nouveau_context(base);
+ struct nouveau_renderer * renderer;
+ struct nvc0_fifo fifo = { };
+ int ret;
+
+ if (!(renderer = malloc(sizeof *renderer)))
+ goto error0;
+
+ ret = nouveau_object_new(&context->device->object, 0,
+ NOUVEAU_FIFO_CHANNEL_CLASS, &fifo, sizeof fifo,
+ &renderer->channel);
+
+ if (ret != 0)
+ goto error1;
+
+ ret = nouveau_pushbuf_new(context->client, renderer->channel, 4, 32 * 1024,
+ true, &renderer->pushbuf);
+
+ if (ret != 0)
+ goto error2;
+
+ if (nouveau_bufctx_new(context->client, 1, &renderer->bufctx) != 0)
+ goto error3;
+
+ if (!nvc0_2d_initialize(renderer))
+ goto error4;
+
+ renderer_initialize(&renderer->base, &wld_renderer_impl);
+ renderer->target = NULL;
+
+ return &renderer->base;
+
+ error4:
+ nouveau_bufctx_del(&renderer->bufctx);
+ error3:
+ nouveau_pushbuf_del(&renderer->pushbuf);
+ error2:
+ nouveau_object_del(&renderer->channel);
+ error1:
+ free(renderer);
+ error0:
+ return NULL;
+}
+
+static bool export(struct wld_exporter * exporter, struct wld_buffer * base,
+ uint32_t type, union wld_object * object)
+{
+ struct nouveau_buffer * buffer = nouveau_buffer(base);
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_HANDLE:
+ object->u32 = buffer->bo->handle;
+ return true;
+ case WLD_DRM_OBJECT_PRIME_FD:
+ if (nouveau_bo_set_prime(buffer->bo, &object->i) != 0)
+ return false;
+ return true;
+ default:
+ return false;
+ }
+}
+
+static struct nouveau_buffer * new_buffer(struct nouveau_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ struct nouveau_buffer * buffer;
+
+ if (!(buffer = malloc(sizeof *buffer)))
+ return NULL;
+
+ buffer_initialize(&buffer->base, &wld_buffer_impl,
+ width, height, format, pitch);
+ buffer->context = context;
+ buffer->exporter.export = &export;
+ wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
+
+ return buffer;
+}
+
+static inline uint32_t roundup(uint32_t value, uint32_t alignment)
+{
+ return (value + alignment - 1) & ~(alignment - 1);
+}
+
+struct buffer * context_create_buffer(struct wld_context * base,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct nouveau_context * context = nouveau_context(base);
+ struct nouveau_buffer * buffer;
+ uint32_t bpp = format_bytes_per_pixel(format),
+ pitch = roundup(width * bpp, 64), bo_flags;
+ union nouveau_bo_config config = { };
+
+ if (!(buffer = new_buffer(context, width, height, format, pitch)))
+ goto error0;
+
+ bo_flags = NOUVEAU_BO_VRAM;
+
+ if (flags & WLD_DRM_FLAG_SCANOUT)
+ bo_flags |= NOUVEAU_BO_CONTIG;
+
+ if (height > 0x40 && !(flags & WLD_FLAG_MAP))
+ {
+ config.nvc0.tile_mode = 0x40;
+ config.nvc0.memtype = 0xfe;
+ height = roundup(height, 0x80);
+ }
+ else
+ bo_flags |= NOUVEAU_BO_MAP;
+
+ if (nouveau_bo_new(context->device, bo_flags, 0, pitch * height,
+ &config, &buffer->bo) != 0)
+ {
+ goto error1;
+ }
+
+ return &buffer->base;
+
+ error1:
+ free(buffer);
+ error0:
+ return NULL;
+}
+
+struct buffer * context_import_buffer(struct wld_context * base,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ struct nouveau_context * context = (void *) base;
+ struct nouveau_buffer * buffer;
+ struct nouveau_bo * bo = NULL;
+
+ switch (type)
+ {
+ case WLD_DRM_OBJECT_PRIME_FD:
+ if (nouveau_bo_prime_handle_ref(context->device,
+ object.i, &bo) != 0)
+ {
+ goto error0;
+ }
+ break;
+ default: goto error0;
+ }
+
+ if (!(buffer = new_buffer(context, width, height, format, pitch)))
+ goto error1;
+
+ buffer->bo = bo;
+
+ return &buffer->base;
+
+ error1:
+ nouveau_bo_ref(NULL, &buffer->bo);
+ error0:
+ return NULL;
+}
+
+void context_destroy(struct wld_context * base)
+{
+ struct nouveau_context * context = nouveau_context(base);
+
+ nouveau_client_del(&context->client);
+ nouveau_device_del(&context->device);
+ free(context);
+}
+
+/**** Renderer ****/
+uint32_t renderer_capabilities(struct wld_renderer * renderer,
+ struct buffer * buffer)
+{
+ if (buffer->base.impl == &wld_buffer_impl)
+ return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
+
+ return 0;
+}
+
+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+
+ if (buffer && buffer->base.impl != &wld_buffer_impl)
+ return false;
+
+ renderer->target = buffer ? nouveau_buffer(&buffer->base) : NULL;
+
+ return true;
+}
+
+static inline void nvc0_2d_use_buffer(struct nouveau_renderer * renderer,
+ struct nouveau_buffer * buffer,
+ uint16_t format_method, uint16_t format)
+{
+ uint32_t access = format == G80_2D_SRC_FORMAT ? NOUVEAU_BO_RD
+ : NOUVEAU_BO_WR;
+
+ nvc0_2d_inline(renderer->pushbuf, format_method, format);
+
+ if (buffer->bo->config.nvc0.memtype)
+ {
+ nvc0_2d(renderer->pushbuf, format_method + 0x04, 2,
+ 0, buffer->bo->config.nvc0.tile_mode);
+ }
+ else
+ {
+ nvc0_2d_inline(renderer->pushbuf, format_method + 0x04, 1);
+ nvc0_2d(renderer->pushbuf, format_method + 0x14, 1,
+ buffer->base.base.pitch);
+ }
+
+ nvc0_2d(renderer->pushbuf, format_method + 0x18, 4,
+ buffer->base.base.width, buffer->base.base.height,
+ buffer->bo->offset >> 32, buffer->bo->offset);
+ nouveau_bufctx_refn(renderer->bufctx, 0, buffer->bo,
+ NOUVEAU_BO_VRAM | access);
+}
+
+void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
+ int32_t x, int32_t y,
+ uint32_t width, uint32_t height)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+ struct nouveau_buffer * dst = renderer->target;
+ uint32_t format;
+
+ if (!ensure_space(renderer->pushbuf, 18))
+ return;
+
+ format = nvc0_format(dst->base.base.format);
+
+ nouveau_bufctx_reset(renderer->bufctx, 0);
+ nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, format);
+ nvc0_2d(renderer->pushbuf, G80_2D_DRAW_SHAPE, 3,
+ G80_2D_DRAW_SHAPE_RECTANGLES, format, color);
+ nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
+
+ if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
+ return;
+
+ nvc0_2d(renderer->pushbuf, G80_2D_DRAW_POINT32_X(0), 4,
+ x, y, x + width, y + height);
+}
+
+void renderer_copy_rectangle(struct wld_renderer * base,
+ struct buffer * buffer_base,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+
+ if (buffer_base->base.impl != &wld_buffer_impl)
+ return;
+
+ struct nouveau_buffer * src = nouveau_buffer(&buffer_base->base),
+ * dst = renderer->target;
+ uint32_t src_format, dst_format;
+
+ if (!ensure_space(renderer->pushbuf, 33))
+ return;
+
+ src_format = nvc0_format(src->base.base.format);
+ dst_format = nvc0_format(dst->base.base.format);
+
+ nouveau_bufctx_reset(renderer->bufctx, 0);
+ nvc0_2d_use_buffer(renderer, src, G80_2D_SRC_FORMAT, src_format);
+ nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, dst_format);
+ nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
+
+ if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
+ return;
+
+ nvc0_2d_inline(renderer->pushbuf, G80_GRAPH_SERIALIZE, 0);
+ nvc0_2d_inline(renderer->pushbuf, G80_2D_BLIT_CONTROL,
+ G80_2D_BLIT_CONTROL_ORIGIN_CENTER
+ | G80_2D_BLIT_CONTROL_FILTER_POINT_SAMPLE);
+ nvc0_2d(renderer->pushbuf, G80_2D_BLIT_DST_X, 12,
+ dst_x, dst_y, width, height, 0, 1, 0, 1, 0, src_x, 0, src_y);
+
+ renderer_flush(base);
+}
+
+void renderer_draw_text(struct wld_renderer * base,
+ struct font * font, uint32_t color,
+ int32_t x, int32_t y, const char * text,
+ uint32_t length, struct wld_extents * extents)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+ struct nouveau_buffer * dst = renderer->target;
+ uint32_t format;
+ int ret;
+ struct glyph * glyph;
+ FT_UInt glyph_index;
+ uint32_t c, count;
+ int32_t origin_x = x;
+
+ if (!ensure_space(renderer->pushbuf, 17))
+ return;
+
+ format = nvc0_format(dst->base.base.format);
+
+ nouveau_bufctx_reset(renderer->bufctx, 0);
+ nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, format);
+ nvc0_2d_inline(renderer->pushbuf, G80_2D_SIFC_BITMAP_ENABLE, 1);
+ nvc0_2d(renderer->pushbuf, G80_2D_SIFC_BITMAP_FORMAT, 6,
+ G80_2D_SIFC_BITMAP_FORMAT_I1,
+ 0, /* SIFC_FORMAT */
+ G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_BYTE,
+ 0, color, /* SIFC_BITMAP_COLOR_BIT0, SIFC_BITMAP_COLOR_BIT1 */
+ 0 /* SIFC_BITMAP_WRITE_BIT0_ENABLE */
+ );
+ nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
+
+ if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
+ return;
+
+ if (length == -1)
+ length = strlen(text);
+
+ while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0')
+ {
+ text += ret;
+ length -= ret;
+ glyph_index = FT_Get_Char_Index(font->face, c);
+
+ if (!font_ensure_glyph(font, glyph_index))
+ continue;
+
+ glyph = font->glyphs[glyph_index];
+
+ if (glyph->bitmap.width == 0 || glyph->bitmap.rows == 0)
+ goto advance;
+
+ count = (glyph->bitmap.pitch * glyph->bitmap.rows + 3) / 4;
+
+ if (!ensure_space(renderer->pushbuf, 12 + count))
+ return;
+
+ nvc0_2d(renderer->pushbuf, G80_2D_SIFC_WIDTH, 10,
+ /* Use the pitch instead of width to ensure the correct
+ * alignment is used. */
+ glyph->bitmap.pitch * 8, glyph->bitmap.rows,
+ 0, 1, 0, 1,
+ 0, origin_x + glyph->x, 0, y + glyph->y);
+ nv_add_dword(renderer->pushbuf,
+ nvc0_command(GF100_COMMAND_TYPE_NON_INCREASING,
+ GF100_SUBCHANNEL_2D,
+ G80_2D_SIFC_DATA, count));
+ nv_add_data(renderer->pushbuf, glyph->bitmap.buffer, count);
+
+ advance:
+ origin_x += glyph->advance;
+ }
+
+ if (extents)
+ extents->advance = origin_x - x;
+}
+
+void renderer_flush(struct wld_renderer * base)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+
+ nouveau_pushbuf_kick(renderer->pushbuf, renderer->channel);
+ nouveau_pushbuf_bufctx(renderer->pushbuf, NULL);
+}
+
+void renderer_destroy(struct wld_renderer * base)
+{
+ struct nouveau_renderer * renderer = nouveau_renderer(base);
+
+ nvc0_2d_finalize(renderer);
+ nouveau_bufctx_del(&renderer->bufctx);
+ nouveau_pushbuf_del(&renderer->pushbuf);
+ nouveau_object_del(&renderer->channel);
+ free(renderer);
+}
+
+/**** Buffer ****/
+bool buffer_map(struct buffer * base)
+{
+ struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
+
+ /* If the buffer is tiled, it cannot be mapped into virtual memory in order
+ * to appear linear like intel can do with map_gtt. */
+ if (buffer->bo->config.nvc0.tile_mode)
+ return false;
+
+ if (nouveau_bo_map(buffer->bo, NOUVEAU_BO_WR,
+ buffer->context->client) != 0)
+ {
+ return false;
+ }
+
+ buffer->base.base.map = buffer->bo->map;
+
+ return true;
+}
+
+bool buffer_unmap(struct buffer * base)
+{
+ struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
+
+ if (munmap(buffer->bo->map, buffer->bo->size) == -1)
+ return false;
+
+ buffer->bo->map = NULL;
+ base->base.map = NULL;
+
+ return true;
+}
+
+void buffer_destroy(struct buffer * base)
+{
+ struct nouveau_buffer * buffer = nouveau_buffer(&base->base);
+
+ nouveau_bo_ref(NULL, &buffer->bo);
+ free(buffer);
+}
+
diff --git a/src/wld/nouveau/g80_2d.xml.h b/src/wld/nouveau/g80_2d.xml.h
index 14b03d5..9ac44a3 100644
--- a/src/wld/nouveau/g80_2d.xml.h
+++ b/src/wld/nouveau/g80_2d.xml.h
@@ -3,255 +3,133 @@
/* Autogenerated file, DO NOT EDIT manually!
-This file was generated by the rules-ng-ng headergen tool in this git
-repository: http://github.com/envytools/envytools/ git clone
-https://github.com/envytools/envytools.git
+This file was generated by the rules-ng-ng headergen tool in this git repository:
+http://github.com/envytools/envytools/
+git clone https://github.com/envytools/envytools.git
The rules-ng-ng source files this header was generated from are:
-- /home/michael/src/envytools/rnndb/root.xml ( 514
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/copyright.xml ( 6452
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/falcon.xml ( 17092
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411
-bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/root.xml ( 514 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/copyright.xml ( 6452 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/falcon.xml ( 17092 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411 bytes, from 2014-11-02 20:39:42)
Copyright (C) 2006-2014 by the following authors:
- Artur Huillet <arthur.huillet@free.fr> (ahuillet)
@@ -311,355 +189,359 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#define G80_2D_DMA_NOTIFY 0x00000180
-#define G80_2D_DMA_DST 0x00000184
-#define G80_2D_DMA_SRC 0x00000188
-#define G80_2D_DMA_COND 0x0000018c
+#define G80_2D_DMA_NOTIFY 0x00000180
-#define G80_2D_DST_FORMAT 0x00000200
+#define G80_2D_DMA_DST 0x00000184
-#define G80_2D_DST_LINEAR 0x00000204
+#define G80_2D_DMA_SRC 0x00000188
-#define G80_2D_DST_TILE_MODE 0x00000208
+#define G80_2D_DMA_COND 0x0000018c
-#define G80_2D_DST_DEPTH 0x0000020c
+#define G80_2D_DST_FORMAT 0x00000200
-#define G80_2D_DST_LAYER 0x00000210
+#define G80_2D_DST_LINEAR 0x00000204
-#define G80_2D_DST_PITCH 0x00000214
+#define G80_2D_DST_TILE_MODE 0x00000208
-#define G80_2D_DST_WIDTH 0x00000218
+#define G80_2D_DST_DEPTH 0x0000020c
-#define G80_2D_DST_HEIGHT 0x0000021c
+#define G80_2D_DST_LAYER 0x00000210
-#define G80_2D_DST_ADDRESS_HIGH 0x00000220
+#define G80_2D_DST_PITCH 0x00000214
-#define G80_2D_DST_ADDRESS_LOW 0x00000224
+#define G80_2D_DST_WIDTH 0x00000218
-#define G80_2D_UNK228 0x00000228
+#define G80_2D_DST_HEIGHT 0x0000021c
-#define GF100_2D_UNK228 0x00000228
+#define G80_2D_DST_ADDRESS_HIGH 0x00000220
-#define GF100_2D_UNK22C 0x0000022c
+#define G80_2D_DST_ADDRESS_LOW 0x00000224
-#define G80_2D_SRC_FORMAT 0x00000230
+#define G80_2D_UNK228 0x00000228
-#define G80_2D_SRC_LINEAR 0x00000234
+#define GF100_2D_UNK228 0x00000228
-#define G80_2D_SRC_TILE_MODE 0x00000238
+#define GF100_2D_UNK22C 0x0000022c
-#define G80_2D_SRC_DEPTH 0x0000023c
+#define G80_2D_SRC_FORMAT 0x00000230
-#define G80_2D_SRC_LAYER 0x00000240
+#define G80_2D_SRC_LINEAR 0x00000234
-#define GF100_2D_UNK0240 0x00000240
+#define G80_2D_SRC_TILE_MODE 0x00000238
-#define G80_2D_SRC_PITCH 0x00000244
-#define G80_2D_SRC_PITCH__MAX 0x00040000
+#define G80_2D_SRC_DEPTH 0x0000023c
-#define G80_2D_SRC_WIDTH 0x00000248
-#define G80_2D_SRC_WIDTH__MAX 0x00010000
+#define G80_2D_SRC_LAYER 0x00000240
-#define G80_2D_SRC_HEIGHT 0x0000024c
-#define G80_2D_SRC_HEIGHT__MAX 0x00010000
+#define GF100_2D_UNK0240 0x00000240
-#define G80_2D_SRC_ADDRESS_HIGH 0x00000250
+#define G80_2D_SRC_PITCH 0x00000244
+#define G80_2D_SRC_PITCH__MAX 0x00040000
-#define G80_2D_SRC_ADDRESS_LOW 0x00000254
+#define G80_2D_SRC_WIDTH 0x00000248
+#define G80_2D_SRC_WIDTH__MAX 0x00010000
-#define G80_2D_UNK258 0x00000258
+#define G80_2D_SRC_HEIGHT 0x0000024c
+#define G80_2D_SRC_HEIGHT__MAX 0x00010000
-#define GF100_2D_UNK25C 0x0000025c
+#define G80_2D_SRC_ADDRESS_HIGH 0x00000250
-#define G80_2D_UNK260 0x00000260
+#define G80_2D_SRC_ADDRESS_LOW 0x00000254
-#define GF100_2D_SINGLE_GPC 0x00000260
+#define G80_2D_UNK258 0x00000258
-#define G80_2D_COND_ADDRESS_HIGH 0x00000264
+#define GF100_2D_UNK25C 0x0000025c
-#define G80_2D_COND_ADDRESS_LOW 0x00000268
+#define G80_2D_UNK260 0x00000260
-#define G80_2D_COND_MODE 0x0000026c
-#define G80_2D_COND_MODE_NEVER 0x00000000
-#define G80_2D_COND_MODE_ALWAYS 0x00000001
-#define G80_2D_COND_MODE_RES_NON_ZERO 0x00000002
-#define G80_2D_COND_MODE_EQUAL 0x00000003
-#define G80_2D_COND_MODE_NOT_EQUAL 0x00000004
+#define GF100_2D_SINGLE_GPC 0x00000260
-#define GF100_2D_UNK0270(i0) (0x00000270 + 0x4 * (i0))
-#define GF100_2D_UNK0270__ESIZE 0x00000004
-#define GF100_2D_UNK0270__LEN 0x00000004
+#define G80_2D_COND_ADDRESS_HIGH 0x00000264
-#define G80_2D_CLIP_X 0x00000280
+#define G80_2D_COND_ADDRESS_LOW 0x00000268
-#define G80_2D_CLIP_Y 0x00000284
+#define G80_2D_COND_MODE 0x0000026c
+#define G80_2D_COND_MODE_NEVER 0x00000000
+#define G80_2D_COND_MODE_ALWAYS 0x00000001
+#define G80_2D_COND_MODE_RES_NON_ZERO 0x00000002
+#define G80_2D_COND_MODE_EQUAL 0x00000003
+#define G80_2D_COND_MODE_NOT_EQUAL 0x00000004
-#define G80_2D_CLIP_W 0x00000288
+#define GF100_2D_UNK0270(i0) (0x00000270 + 0x4*(i0))
+#define GF100_2D_UNK0270__ESIZE 0x00000004
+#define GF100_2D_UNK0270__LEN 0x00000004
-#define G80_2D_CLIP_H 0x0000028c
+#define G80_2D_CLIP_X 0x00000280
-#define G80_2D_CLIP_ENABLE 0x00000290
+#define G80_2D_CLIP_Y 0x00000284
-#define G80_2D_COLOR_KEY_FORMAT 0x00000294
-#define G80_2D_COLOR_KEY_FORMAT_16BPP 0x00000000
-#define G80_2D_COLOR_KEY_FORMAT_15BPP 0x00000001
-#define G80_2D_COLOR_KEY_FORMAT_24BPP 0x00000002
-#define G80_2D_COLOR_KEY_FORMAT_30BPP 0x00000003
-#define G80_2D_COLOR_KEY_FORMAT_8BPP 0x00000004
-#define G80_2D_COLOR_KEY_FORMAT_16BPP2 0x00000005
-#define G80_2D_COLOR_KEY_FORMAT_32BPP 0x00000006
+#define G80_2D_CLIP_W 0x00000288
-#define G80_2D_COLOR_KEY 0x00000298
+#define G80_2D_CLIP_H 0x0000028c
-#define G80_2D_COLOR_KEY_ENABLE 0x0000029c
+#define G80_2D_CLIP_ENABLE 0x00000290
-#define G80_2D_ROP 0x000002a0
+#define G80_2D_COLOR_KEY_FORMAT 0x00000294
+#define G80_2D_COLOR_KEY_FORMAT_16BPP 0x00000000
+#define G80_2D_COLOR_KEY_FORMAT_15BPP 0x00000001
+#define G80_2D_COLOR_KEY_FORMAT_24BPP 0x00000002
+#define G80_2D_COLOR_KEY_FORMAT_30BPP 0x00000003
+#define G80_2D_COLOR_KEY_FORMAT_8BPP 0x00000004
+#define G80_2D_COLOR_KEY_FORMAT_16BPP2 0x00000005
+#define G80_2D_COLOR_KEY_FORMAT_32BPP 0x00000006
-#define G80_2D_BETA1 0x000002a4
-#define G80_2D_BETA1_BETA1__MASK 0x7f800000
-#define G80_2D_BETA1_BETA1__SHIFT 23
+#define G80_2D_COLOR_KEY 0x00000298
-#define G80_2D_BETA4 0x000002a8
-#define G80_2D_BETA4_B__MASK 0x000000ff
-#define G80_2D_BETA4_B__SHIFT 0
-#define G80_2D_BETA4_G__MASK 0x0000ff00
-#define G80_2D_BETA4_G__SHIFT 8
-#define G80_2D_BETA4_R__MASK 0x00ff0000
-#define G80_2D_BETA4_R__SHIFT 16
-#define G80_2D_BETA4_A__MASK 0xff000000
-#define G80_2D_BETA4_A__SHIFT 24
+#define G80_2D_COLOR_KEY_ENABLE 0x0000029c
-#define G80_2D_OPERATION 0x000002ac
-#define G80_2D_OPERATION_SRCCOPY_AND 0x00000000
-#define G80_2D_OPERATION_ROP_AND 0x00000001
-#define G80_2D_OPERATION_BLEND 0x00000002
-#define G80_2D_OPERATION_SRCCOPY 0x00000003
-#define G80_2D_OPERATION_ROP 0x00000004
-#define G80_2D_OPERATION_SRCCOPY_PREMULT 0x00000005
-#define G80_2D_OPERATION_BLEND_PREMULT 0x00000006
-
-#define G80_2D_PATTERN_OFFSET 0x000002b0
-#define G80_2D_PATTERN_OFFSET_X__MASK 0x0000003f
-#define G80_2D_PATTERN_OFFSET_X__SHIFT 0
-#define G80_2D_PATTERN_OFFSET_Y__MASK 0x00003f00
-#define G80_2D_PATTERN_OFFSET_Y__SHIFT 8
-
-#define G80_2D_PATTERN_SELECT 0x000002b4
-#define G80_2D_PATTERN_SELECT_BITMAP_8X8 0x00000000
-#define G80_2D_PATTERN_SELECT_BITMAP_64X1 0x00000001
-#define G80_2D_PATTERN_SELECT_BITMAP_1X64 0x00000002
-#define G80_2D_PATTERN_SELECT_COLOR 0x00000003
-
-#define GF100_2D_UNK02B8(i0) (0x000002b8 + 0x4 * (i0))
-#define GF100_2D_UNK02B8__ESIZE 0x00000004
-#define GF100_2D_UNK02B8__LEN 0x00000009
-
-#define GF100_2D_UNK2DC 0x000002dc
-
-#define GF100_2D_UNK2E0 0x000002e0
-
-#define GF100_2D_UNK02E4 0x000002e4
-
-#define G80_2D_PATTERN_COLOR_FORMAT 0x000002e8
-#define G80_2D_PATTERN_COLOR_FORMAT_A16R5G6B5 0x00000000
-#define G80_2D_PATTERN_COLOR_FORMAT_X16A1R5G5B5 0x00000001
-#define G80_2D_PATTERN_COLOR_FORMAT_A8R8G8B8 0x00000002
-#define G80_2D_PATTERN_COLOR_FORMAT_X16A8Y8 0x00000003
-#define G80_2D_PATTERN_COLOR_FORMAT_UNK4 0x00000004
-#define G80_2D_PATTERN_COLOR_FORMAT_UNK5 0x00000005
-
-#define G80_2D_PATTERN_BITMAP_FORMAT 0x000002ec
-#define G80_2D_PATTERN_BITMAP_FORMAT_CGA6 0x00000000
-#define G80_2D_PATTERN_BITMAP_FORMAT_LE 0x00000001
-
-#define G80_2D_PATTERN_BITMAP_COLOR(i0) (0x000002f0 + 0x4 * (i0))
-#define G80_2D_PATTERN_BITMAP_COLOR__ESIZE 0x00000004
-#define G80_2D_PATTERN_BITMAP_COLOR__LEN 0x00000002
-
-#define G80_2D_PATTERN_BITMAP(i0) (0x000002f8 + 0x4 * (i0))
-#define G80_2D_PATTERN_BITMAP__ESIZE 0x00000004
-#define G80_2D_PATTERN_BITMAP__LEN 0x00000002
-
-#define G80_2D_PATTERN_X8R8G8B8(i0) (0x00000300 + 0x4 * (i0))
-#define G80_2D_PATTERN_X8R8G8B8__ESIZE 0x00000004
-#define G80_2D_PATTERN_X8R8G8B8__LEN 0x00000040
-#define G80_2D_PATTERN_X8R8G8B8_B__MASK 0x000000ff
-#define G80_2D_PATTERN_X8R8G8B8_B__SHIFT 0
-#define G80_2D_PATTERN_X8R8G8B8_G__MASK 0x0000ff00
-#define G80_2D_PATTERN_X8R8G8B8_G__SHIFT 8
-#define G80_2D_PATTERN_X8R8G8B8_R__MASK 0x00ff0000
-#define G80_2D_PATTERN_X8R8G8B8_R__SHIFT 16
-
-#define G80_2D_PATTERN_R5G6B5(i0) (0x00000400 + 0x4 * (i0))
-#define G80_2D_PATTERN_R5G6B5__ESIZE 0x00000004
-#define G80_2D_PATTERN_R5G6B5__LEN 0x00000020
-#define G80_2D_PATTERN_R5G6B5_B0__MASK 0x0000001f
-#define G80_2D_PATTERN_R5G6B5_B0__SHIFT 0
-#define G80_2D_PATTERN_R5G6B5_G0__MASK 0x000007e0
-#define G80_2D_PATTERN_R5G6B5_G0__SHIFT 5
-#define G80_2D_PATTERN_R5G6B5_R0__MASK 0x0000f800
-#define G80_2D_PATTERN_R5G6B5_R0__SHIFT 11
-#define G80_2D_PATTERN_R5G6B5_B1__MASK 0x001f0000
-#define G80_2D_PATTERN_R5G6B5_B1__SHIFT 16
-#define G80_2D_PATTERN_R5G6B5_G1__MASK 0x07e00000
-#define G80_2D_PATTERN_R5G6B5_G1__SHIFT 21
-#define G80_2D_PATTERN_R5G6B5_R1__MASK 0xf8000000
-#define G80_2D_PATTERN_R5G6B5_R1__SHIFT 27
-
-#define G80_2D_PATTERN_X1R5G5B5(i0) (0x00000480 + 0x4 * (i0))
-#define G80_2D_PATTERN_X1R5G5B5__ESIZE 0x00000004
-#define G80_2D_PATTERN_X1R5G5B5__LEN 0x00000020
-#define G80_2D_PATTERN_X1R5G5B5_B0__MASK 0x0000001f
-#define G80_2D_PATTERN_X1R5G5B5_B0__SHIFT 0
-#define G80_2D_PATTERN_X1R5G5B5_G0__MASK 0x000003e0
-#define G80_2D_PATTERN_X1R5G5B5_G0__SHIFT 5
-#define G80_2D_PATTERN_X1R5G5B5_R0__MASK 0x00007c00
-#define G80_2D_PATTERN_X1R5G5B5_R0__SHIFT 10
-#define G80_2D_PATTERN_X1R5G5B5_B1__MASK 0x001f0000
-#define G80_2D_PATTERN_X1R5G5B5_B1__SHIFT 16
-#define G80_2D_PATTERN_X1R5G5B5_G1__MASK 0x03e00000
-#define G80_2D_PATTERN_X1R5G5B5_G1__SHIFT 21
-#define G80_2D_PATTERN_X1R5G5B5_R1__MASK 0x7c000000
-#define G80_2D_PATTERN_X1R5G5B5_R1__SHIFT 26
-
-#define G80_2D_PATTERN_Y8(i0) (0x00000500 + 0x4 * (i0))
-#define G80_2D_PATTERN_Y8__ESIZE 0x00000004
-#define G80_2D_PATTERN_Y8__LEN 0x00000010
-#define G80_2D_PATTERN_Y8_Y0__MASK 0x000000ff
-#define G80_2D_PATTERN_Y8_Y0__SHIFT 0
-#define G80_2D_PATTERN_Y8_Y1__MASK 0x0000ff00
-#define G80_2D_PATTERN_Y8_Y1__SHIFT 8
-#define G80_2D_PATTERN_Y8_Y2__MASK 0x00ff0000
-#define G80_2D_PATTERN_Y8_Y2__SHIFT 16
-#define G80_2D_PATTERN_Y8_Y3__MASK 0xff000000
-#define G80_2D_PATTERN_Y8_Y3__SHIFT 24
-
-#define GF100_2D_DRAW_COLOR_LONG(i0) (0x00000540 + 0x4 * (i0))
-#define GF100_2D_DRAW_COLOR_LONG__ESIZE 0x00000004
-#define GF100_2D_DRAW_COLOR_LONG__LEN 0x00000004
+#define G80_2D_ROP 0x000002a0
-#define G80_2D_DRAW_SHAPE 0x00000580
-#define G80_2D_DRAW_SHAPE_POINTS 0x00000000
-#define G80_2D_DRAW_SHAPE_LINES 0x00000001
-#define G80_2D_DRAW_SHAPE_LINE_STRIP 0x00000002
-#define G80_2D_DRAW_SHAPE_TRIANGLES 0x00000003
-#define G80_2D_DRAW_SHAPE_RECTANGLES 0x00000004
+#define G80_2D_BETA1 0x000002a4
+#define G80_2D_BETA1_BETA1__MASK 0x7f800000
+#define G80_2D_BETA1_BETA1__SHIFT 23
-#define G80_2D_DRAW_COLOR_FORMAT 0x00000584
+#define G80_2D_BETA4 0x000002a8
+#define G80_2D_BETA4_B__MASK 0x000000ff
+#define G80_2D_BETA4_B__SHIFT 0
+#define G80_2D_BETA4_G__MASK 0x0000ff00
+#define G80_2D_BETA4_G__SHIFT 8
+#define G80_2D_BETA4_R__MASK 0x00ff0000
+#define G80_2D_BETA4_R__SHIFT 16
+#define G80_2D_BETA4_A__MASK 0xff000000
+#define G80_2D_BETA4_A__SHIFT 24
-#define G80_2D_DRAW_COLOR 0x00000588
+#define G80_2D_OPERATION 0x000002ac
+#define G80_2D_OPERATION_SRCCOPY_AND 0x00000000
+#define G80_2D_OPERATION_ROP_AND 0x00000001
+#define G80_2D_OPERATION_BLEND 0x00000002
+#define G80_2D_OPERATION_SRCCOPY 0x00000003
+#define G80_2D_OPERATION_ROP 0x00000004
+#define G80_2D_OPERATION_SRCCOPY_PREMULT 0x00000005
+#define G80_2D_OPERATION_BLEND_PREMULT 0x00000006
+
+#define G80_2D_PATTERN_OFFSET 0x000002b0
+#define G80_2D_PATTERN_OFFSET_X__MASK 0x0000003f
+#define G80_2D_PATTERN_OFFSET_X__SHIFT 0
+#define G80_2D_PATTERN_OFFSET_Y__MASK 0x00003f00
+#define G80_2D_PATTERN_OFFSET_Y__SHIFT 8
+
+#define G80_2D_PATTERN_SELECT 0x000002b4
+#define G80_2D_PATTERN_SELECT_BITMAP_8X8 0x00000000
+#define G80_2D_PATTERN_SELECT_BITMAP_64X1 0x00000001
+#define G80_2D_PATTERN_SELECT_BITMAP_1X64 0x00000002
+#define G80_2D_PATTERN_SELECT_COLOR 0x00000003
+
+#define GF100_2D_UNK02B8(i0) (0x000002b8 + 0x4*(i0))
+#define GF100_2D_UNK02B8__ESIZE 0x00000004
+#define GF100_2D_UNK02B8__LEN 0x00000009
+
+#define GF100_2D_UNK2DC 0x000002dc
+
+#define GF100_2D_UNK2E0 0x000002e0
+
+#define GF100_2D_UNK02E4 0x000002e4
+
+#define G80_2D_PATTERN_COLOR_FORMAT 0x000002e8
+#define G80_2D_PATTERN_COLOR_FORMAT_A16R5G6B5 0x00000000
+#define G80_2D_PATTERN_COLOR_FORMAT_X16A1R5G5B5 0x00000001
+#define G80_2D_PATTERN_COLOR_FORMAT_A8R8G8B8 0x00000002
+#define G80_2D_PATTERN_COLOR_FORMAT_X16A8Y8 0x00000003
+#define G80_2D_PATTERN_COLOR_FORMAT_UNK4 0x00000004
+#define G80_2D_PATTERN_COLOR_FORMAT_UNK5 0x00000005
+
+#define G80_2D_PATTERN_BITMAP_FORMAT 0x000002ec
+#define G80_2D_PATTERN_BITMAP_FORMAT_CGA6 0x00000000
+#define G80_2D_PATTERN_BITMAP_FORMAT_LE 0x00000001
+
+#define G80_2D_PATTERN_BITMAP_COLOR(i0) (0x000002f0 + 0x4*(i0))
+#define G80_2D_PATTERN_BITMAP_COLOR__ESIZE 0x00000004
+#define G80_2D_PATTERN_BITMAP_COLOR__LEN 0x00000002
+
+#define G80_2D_PATTERN_BITMAP(i0) (0x000002f8 + 0x4*(i0))
+#define G80_2D_PATTERN_BITMAP__ESIZE 0x00000004
+#define G80_2D_PATTERN_BITMAP__LEN 0x00000002
+
+#define G80_2D_PATTERN_X8R8G8B8(i0) (0x00000300 + 0x4*(i0))
+#define G80_2D_PATTERN_X8R8G8B8__ESIZE 0x00000004
+#define G80_2D_PATTERN_X8R8G8B8__LEN 0x00000040
+#define G80_2D_PATTERN_X8R8G8B8_B__MASK 0x000000ff
+#define G80_2D_PATTERN_X8R8G8B8_B__SHIFT 0
+#define G80_2D_PATTERN_X8R8G8B8_G__MASK 0x0000ff00
+#define G80_2D_PATTERN_X8R8G8B8_G__SHIFT 8
+#define G80_2D_PATTERN_X8R8G8B8_R__MASK 0x00ff0000
+#define G80_2D_PATTERN_X8R8G8B8_R__SHIFT 16
+
+#define G80_2D_PATTERN_R5G6B5(i0) (0x00000400 + 0x4*(i0))
+#define G80_2D_PATTERN_R5G6B5__ESIZE 0x00000004
+#define G80_2D_PATTERN_R5G6B5__LEN 0x00000020
+#define G80_2D_PATTERN_R5G6B5_B0__MASK 0x0000001f
+#define G80_2D_PATTERN_R5G6B5_B0__SHIFT 0
+#define G80_2D_PATTERN_R5G6B5_G0__MASK 0x000007e0
+#define G80_2D_PATTERN_R5G6B5_G0__SHIFT 5
+#define G80_2D_PATTERN_R5G6B5_R0__MASK 0x0000f800
+#define G80_2D_PATTERN_R5G6B5_R0__SHIFT 11
+#define G80_2D_PATTERN_R5G6B5_B1__MASK 0x001f0000
+#define G80_2D_PATTERN_R5G6B5_B1__SHIFT 16
+#define G80_2D_PATTERN_R5G6B5_G1__MASK 0x07e00000
+#define G80_2D_PATTERN_R5G6B5_G1__SHIFT 21
+#define G80_2D_PATTERN_R5G6B5_R1__MASK 0xf8000000
+#define G80_2D_PATTERN_R5G6B5_R1__SHIFT 27
+
+#define G80_2D_PATTERN_X1R5G5B5(i0) (0x00000480 + 0x4*(i0))
+#define G80_2D_PATTERN_X1R5G5B5__ESIZE 0x00000004
+#define G80_2D_PATTERN_X1R5G5B5__LEN 0x00000020
+#define G80_2D_PATTERN_X1R5G5B5_B0__MASK 0x0000001f
+#define G80_2D_PATTERN_X1R5G5B5_B0__SHIFT 0
+#define G80_2D_PATTERN_X1R5G5B5_G0__MASK 0x000003e0
+#define G80_2D_PATTERN_X1R5G5B5_G0__SHIFT 5
+#define G80_2D_PATTERN_X1R5G5B5_R0__MASK 0x00007c00
+#define G80_2D_PATTERN_X1R5G5B5_R0__SHIFT 10
+#define G80_2D_PATTERN_X1R5G5B5_B1__MASK 0x001f0000
+#define G80_2D_PATTERN_X1R5G5B5_B1__SHIFT 16
+#define G80_2D_PATTERN_X1R5G5B5_G1__MASK 0x03e00000
+#define G80_2D_PATTERN_X1R5G5B5_G1__SHIFT 21
+#define G80_2D_PATTERN_X1R5G5B5_R1__MASK 0x7c000000
+#define G80_2D_PATTERN_X1R5G5B5_R1__SHIFT 26
+
+#define G80_2D_PATTERN_Y8(i0) (0x00000500 + 0x4*(i0))
+#define G80_2D_PATTERN_Y8__ESIZE 0x00000004
+#define G80_2D_PATTERN_Y8__LEN 0x00000010
+#define G80_2D_PATTERN_Y8_Y0__MASK 0x000000ff
+#define G80_2D_PATTERN_Y8_Y0__SHIFT 0
+#define G80_2D_PATTERN_Y8_Y1__MASK 0x0000ff00
+#define G80_2D_PATTERN_Y8_Y1__SHIFT 8
+#define G80_2D_PATTERN_Y8_Y2__MASK 0x00ff0000
+#define G80_2D_PATTERN_Y8_Y2__SHIFT 16
+#define G80_2D_PATTERN_Y8_Y3__MASK 0xff000000
+#define G80_2D_PATTERN_Y8_Y3__SHIFT 24
+
+#define GF100_2D_DRAW_COLOR_LONG(i0) (0x00000540 + 0x4*(i0))
+#define GF100_2D_DRAW_COLOR_LONG__ESIZE 0x00000004
+#define GF100_2D_DRAW_COLOR_LONG__LEN 0x00000004
-#define G80_2D_UNK58C 0x0000058c
-#define G80_2D_UNK58C_0 0x00000001
-#define G80_2D_UNK58C_1 0x00000010
-#define G80_2D_UNK58C_2 0x00000100
-#define G80_2D_UNK58C_3 0x00001000
+#define G80_2D_DRAW_SHAPE 0x00000580
+#define G80_2D_DRAW_SHAPE_POINTS 0x00000000
+#define G80_2D_DRAW_SHAPE_LINES 0x00000001
+#define G80_2D_DRAW_SHAPE_LINE_STRIP 0x00000002
+#define G80_2D_DRAW_SHAPE_TRIANGLES 0x00000003
+#define G80_2D_DRAW_SHAPE_RECTANGLES 0x00000004
-#define G80_2D_DRAW_POINT16 0x000005e0
-#define G80_2D_DRAW_POINT16_X__MASK 0x0000ffff
-#define G80_2D_DRAW_POINT16_X__SHIFT 0
-#define G80_2D_DRAW_POINT16_Y__MASK 0xffff0000
-#define G80_2D_DRAW_POINT16_Y__SHIFT 16
+#define G80_2D_DRAW_COLOR_FORMAT 0x00000584
-#define G80_2D_DRAW_POINT32_X(i0) (0x00000600 + 0x8 * (i0))
-#define G80_2D_DRAW_POINT32_X__ESIZE 0x00000008
-#define G80_2D_DRAW_POINT32_X__LEN 0x00000040
+#define G80_2D_DRAW_COLOR 0x00000588
-#define G80_2D_DRAW_POINT32_Y(i0) (0x00000604 + 0x8 * (i0))
-#define G80_2D_DRAW_POINT32_Y__ESIZE 0x00000008
-#define G80_2D_DRAW_POINT32_Y__LEN 0x00000040
+#define G80_2D_UNK58C 0x0000058c
+#define G80_2D_UNK58C_0 0x00000001
+#define G80_2D_UNK58C_1 0x00000010
+#define G80_2D_UNK58C_2 0x00000100
+#define G80_2D_UNK58C_3 0x00001000
-#define G80_2D_SIFC_BITMAP_ENABLE 0x00000800
+#define G80_2D_DRAW_POINT16 0x000005e0
+#define G80_2D_DRAW_POINT16_X__MASK 0x0000ffff
+#define G80_2D_DRAW_POINT16_X__SHIFT 0
+#define G80_2D_DRAW_POINT16_Y__MASK 0xffff0000
+#define G80_2D_DRAW_POINT16_Y__SHIFT 16
-#define G80_2D_SIFC_FORMAT 0x00000804
+#define G80_2D_DRAW_POINT32_X(i0) (0x00000600 + 0x8*(i0))
+#define G80_2D_DRAW_POINT32_X__ESIZE 0x00000008
+#define G80_2D_DRAW_POINT32_X__LEN 0x00000040
-#define G80_2D_SIFC_BITMAP_FORMAT 0x00000808
-#define G80_2D_SIFC_BITMAP_FORMAT_I1 0x00000000
-#define G80_2D_SIFC_BITMAP_FORMAT_I4 0x00000001
-#define G80_2D_SIFC_BITMAP_FORMAT_I8 0x00000002
+#define G80_2D_DRAW_POINT32_Y(i0) (0x00000604 + 0x8*(i0))
+#define G80_2D_DRAW_POINT32_Y__ESIZE 0x00000008
+#define G80_2D_DRAW_POINT32_Y__LEN 0x00000040
-#define G80_2D_SIFC_BITMAP_LSB_FIRST 0x0000080c
+#define G80_2D_SIFC_BITMAP_ENABLE 0x00000800
-#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE 0x00000810
-#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_PACKED 0x00000000
-#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_BYTE 0x00000001
-#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_WORD 0x00000002
+#define G80_2D_SIFC_FORMAT 0x00000804
-#define G80_2D_SIFC_BITMAP_COLOR_BIT0 0x00000814
+#define G80_2D_SIFC_BITMAP_FORMAT 0x00000808
+#define G80_2D_SIFC_BITMAP_FORMAT_I1 0x00000000
+#define G80_2D_SIFC_BITMAP_FORMAT_I4 0x00000001
+#define G80_2D_SIFC_BITMAP_FORMAT_I8 0x00000002
-#define G80_2D_SIFC_BITMAP_COLOR_BIT1 0x00000818
+#define G80_2D_SIFC_BITMAP_LSB_FIRST 0x0000080c
-#define G80_2D_SIFC_BITMAP_WRITE_BIT0_ENABLE 0x0000081c
+#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE 0x00000810
+#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_PACKED 0x00000000
+#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_BYTE 0x00000001
+#define G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_WORD 0x00000002
-#define G80_2D_SIFC_WIDTH 0x00000838
+#define G80_2D_SIFC_BITMAP_COLOR_BIT0 0x00000814
-#define G80_2D_SIFC_HEIGHT 0x0000083c
+#define G80_2D_SIFC_BITMAP_COLOR_BIT1 0x00000818
-#define G80_2D_SIFC_DX_DU_FRACT 0x00000840
+#define G80_2D_SIFC_BITMAP_WRITE_BIT0_ENABLE 0x0000081c
-#define G80_2D_SIFC_DX_DU_INT 0x00000844
+#define G80_2D_SIFC_WIDTH 0x00000838
-#define G80_2D_SIFC_DY_DV_FRACT 0x00000848
+#define G80_2D_SIFC_HEIGHT 0x0000083c
-#define G80_2D_SIFC_DY_DV_INT 0x0000084c
+#define G80_2D_SIFC_DX_DU_FRACT 0x00000840
-#define G80_2D_SIFC_DST_X_FRACT 0x00000850
+#define G80_2D_SIFC_DX_DU_INT 0x00000844
-#define G80_2D_SIFC_DST_X_INT 0x00000854
+#define G80_2D_SIFC_DY_DV_FRACT 0x00000848
-#define G80_2D_SIFC_DST_Y_FRACT 0x00000858
+#define G80_2D_SIFC_DY_DV_INT 0x0000084c
-#define G80_2D_SIFC_DST_Y_INT 0x0000085c
+#define G80_2D_SIFC_DST_X_FRACT 0x00000850
-#define G80_2D_SIFC_DATA 0x00000860
+#define G80_2D_SIFC_DST_X_INT 0x00000854
-#define G80_2D_UNK0870 0x00000870
+#define G80_2D_SIFC_DST_Y_FRACT 0x00000858
-#define G80_2D_UNK0880 0x00000880
+#define G80_2D_SIFC_DST_Y_INT 0x0000085c
-#define G80_2D_UNK0884 0x00000884
+#define G80_2D_SIFC_DATA 0x00000860
-#define G80_2D_UNK0888 0x00000888
+#define G80_2D_UNK0870 0x00000870
-#define G80_2D_BLIT_CONTROL 0x0000088c
-#define G80_2D_BLIT_CONTROL_ORIGIN__MASK 0x00000001
-#define G80_2D_BLIT_CONTROL_ORIGIN__SHIFT 0
-#define G80_2D_BLIT_CONTROL_ORIGIN_CENTER 0x00000000
-#define G80_2D_BLIT_CONTROL_ORIGIN_CORNER 0x00000001
-#define G80_2D_BLIT_CONTROL_FILTER__MASK 0x00000010
-#define G80_2D_BLIT_CONTROL_FILTER__SHIFT 4
-#define G80_2D_BLIT_CONTROL_FILTER_POINT_SAMPLE 0x00000000
-#define G80_2D_BLIT_CONTROL_FILTER_BILINEAR 0x00000010
+#define G80_2D_UNK0880 0x00000880
-#define G80_2D_BLIT_DST_X 0x000008b0
+#define G80_2D_UNK0884 0x00000884
-#define G80_2D_BLIT_DST_Y 0x000008b4
+#define G80_2D_UNK0888 0x00000888
-#define G80_2D_BLIT_DST_W 0x000008b8
+#define G80_2D_BLIT_CONTROL 0x0000088c
+#define G80_2D_BLIT_CONTROL_ORIGIN__MASK 0x00000001
+#define G80_2D_BLIT_CONTROL_ORIGIN__SHIFT 0
+#define G80_2D_BLIT_CONTROL_ORIGIN_CENTER 0x00000000
+#define G80_2D_BLIT_CONTROL_ORIGIN_CORNER 0x00000001
+#define G80_2D_BLIT_CONTROL_FILTER__MASK 0x00000010
+#define G80_2D_BLIT_CONTROL_FILTER__SHIFT 4
+#define G80_2D_BLIT_CONTROL_FILTER_POINT_SAMPLE 0x00000000
+#define G80_2D_BLIT_CONTROL_FILTER_BILINEAR 0x00000010
-#define G80_2D_BLIT_DST_H 0x000008bc
+#define G80_2D_BLIT_DST_X 0x000008b0
-#define G80_2D_BLIT_DU_DX_FRACT 0x000008c0
+#define G80_2D_BLIT_DST_Y 0x000008b4
-#define G80_2D_BLIT_DU_DX_INT 0x000008c4
+#define G80_2D_BLIT_DST_W 0x000008b8
-#define G80_2D_BLIT_DV_DY_FRACT 0x000008c8
+#define G80_2D_BLIT_DST_H 0x000008bc
-#define G80_2D_BLIT_DV_DY_INT 0x000008cc
+#define G80_2D_BLIT_DU_DX_FRACT 0x000008c0
-#define G80_2D_BLIT_SRC_X_FRACT 0x000008d0
+#define G80_2D_BLIT_DU_DX_INT 0x000008c4
-#define G80_2D_BLIT_SRC_X_INT 0x000008d4
+#define G80_2D_BLIT_DV_DY_FRACT 0x000008c8
-#define G80_2D_BLIT_SRC_Y_FRACT 0x000008d8
+#define G80_2D_BLIT_DV_DY_INT 0x000008cc
-#define G80_2D_BLIT_SRC_Y_INT 0x000008dc
+#define G80_2D_BLIT_SRC_X_FRACT 0x000008d0
+
+#define G80_2D_BLIT_SRC_X_INT 0x000008d4
+
+#define G80_2D_BLIT_SRC_Y_FRACT 0x000008d8
+
+#define G80_2D_BLIT_SRC_Y_INT 0x000008dc
+
+#define GF100_2D_FIRMWARE(i0) (0x000008e0 + 0x4*(i0))
+#define GF100_2D_FIRMWARE__ESIZE 0x00000004
+#define GF100_2D_FIRMWARE__LEN 0x00000020
-#define GF100_2D_FIRMWARE(i0) (0x000008e0 + 0x4 * (i0))
-#define GF100_2D_FIRMWARE__ESIZE 0x00000004
-#define GF100_2D_FIRMWARE__LEN 0x00000020
#endif /* G80_2D_XML */
diff --git a/src/wld/nouveau/g80_defs.xml.h b/src/wld/nouveau/g80_defs.xml.h
index 112e437..ba7df43 100644
--- a/src/wld/nouveau/g80_defs.xml.h
+++ b/src/wld/nouveau/g80_defs.xml.h
@@ -3,255 +3,133 @@
/* Autogenerated file, DO NOT EDIT manually!
-This file was generated by the rules-ng-ng headergen tool in this git
-repository: http://github.com/envytools/envytools/ git clone
-https://github.com/envytools/envytools.git
+This file was generated by the rules-ng-ng headergen tool in this git repository:
+http://github.com/envytools/envytools/
+git clone https://github.com/envytools/envytools.git
The rules-ng-ng source files this header was generated from are:
-- /home/michael/src/envytools/rnndb/root.xml ( 514
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/copyright.xml ( 6452
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/falcon.xml ( 17092
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411
-bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/root.xml ( 514 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/copyright.xml ( 6452 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/falcon.xml ( 17092 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411 bytes, from 2014-11-02 20:39:42)
Copyright (C) 2006-2014 by the following authors:
- Artur Huillet <arthur.huillet@free.fr> (ahuillet)
@@ -311,192 +189,194 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#define G80_VSTATUS_IDLE 0x00000000
-#define G80_VSTATUS_BUSY 0x00000001
-#define G80_VSTATUS_UNK2 0x00000002
-#define G80_VSTATUS_WAITING 0x00000003
-#define G80_VSTATUS_BLOCKED 0x00000005
-#define G80_VSTATUS_FAULTED 0x00000006
-#define G80_VSTATUS_PAUSED 0x00000007
-#define G80_SURFACE_FORMAT_BITMAP 0x0000001c
-#define G80_SURFACE_FORMAT_UNK1D 0x0000001d
-#define G80_SURFACE_FORMAT_RGBA32_FLOAT 0x000000c0
-#define G80_SURFACE_FORMAT_RGBA32_SINT 0x000000c1
-#define G80_SURFACE_FORMAT_RGBA32_UINT 0x000000c2
-#define G80_SURFACE_FORMAT_RGBX32_FLOAT 0x000000c3
-#define G80_SURFACE_FORMAT_RGBX32_SINT 0x000000c4
-#define G80_SURFACE_FORMAT_RGBX32_UINT 0x000000c5
-#define G80_SURFACE_FORMAT_RGBA16_UNORM 0x000000c6
-#define G80_SURFACE_FORMAT_RGBA16_SNORM 0x000000c7
-#define G80_SURFACE_FORMAT_RGBA16_SINT 0x000000c8
-#define G80_SURFACE_FORMAT_RGBA16_UINT 0x000000c9
-#define G80_SURFACE_FORMAT_RGBA16_FLOAT 0x000000ca
-#define G80_SURFACE_FORMAT_RG32_FLOAT 0x000000cb
-#define G80_SURFACE_FORMAT_RG32_SINT 0x000000cc
-#define G80_SURFACE_FORMAT_RG32_UINT 0x000000cd
-#define G80_SURFACE_FORMAT_RGBX16_FLOAT 0x000000ce
-#define G80_SURFACE_FORMAT_BGRA8_UNORM 0x000000cf
-#define G80_SURFACE_FORMAT_BGRA8_SRGB 0x000000d0
-#define G80_SURFACE_FORMAT_RGB10_A2_UNORM 0x000000d1
-#define G80_SURFACE_FORMAT_RGB10_A2_UINT 0x000000d2
-#define G80_SURFACE_FORMAT_RGBA8_UNORM 0x000000d5
-#define G80_SURFACE_FORMAT_RGBA8_SRGB 0x000000d6
-#define G80_SURFACE_FORMAT_RGBA8_SNORM 0x000000d7
-#define G80_SURFACE_FORMAT_RGBA8_SINT 0x000000d8
-#define G80_SURFACE_FORMAT_RGBA8_UINT 0x000000d9
-#define G80_SURFACE_FORMAT_RG16_UNORM 0x000000da
-#define G80_SURFACE_FORMAT_RG16_SNORM 0x000000db
-#define G80_SURFACE_FORMAT_RG16_SINT 0x000000dc
-#define G80_SURFACE_FORMAT_RG16_UINT 0x000000dd
-#define G80_SURFACE_FORMAT_RG16_FLOAT 0x000000de
-#define G80_SURFACE_FORMAT_BGR10_A2_UNORM 0x000000df
-#define G80_SURFACE_FORMAT_R11G11B10_FLOAT 0x000000e0
-#define G80_SURFACE_FORMAT_R32_SINT 0x000000e3
-#define G80_SURFACE_FORMAT_R32_UINT 0x000000e4
-#define G80_SURFACE_FORMAT_R32_FLOAT 0x000000e5
-#define G80_SURFACE_FORMAT_BGRX8_UNORM 0x000000e6
-#define G80_SURFACE_FORMAT_BGRX8_SRGB 0x000000e7
-#define G80_SURFACE_FORMAT_B5G6R5_UNORM 0x000000e8
-#define G80_SURFACE_FORMAT_BGR5_A1_UNORM 0x000000e9
-#define G80_SURFACE_FORMAT_RG8_UNORM 0x000000ea
-#define G80_SURFACE_FORMAT_RG8_SNORM 0x000000eb
-#define G80_SURFACE_FORMAT_RG8_SINT 0x000000ec
-#define G80_SURFACE_FORMAT_RG8_UINT 0x000000ed
-#define G80_SURFACE_FORMAT_R16_UNORM 0x000000ee
-#define G80_SURFACE_FORMAT_R16_SNORM 0x000000ef
-#define G80_SURFACE_FORMAT_R16_SINT 0x000000f0
-#define G80_SURFACE_FORMAT_R16_UINT 0x000000f1
-#define G80_SURFACE_FORMAT_R16_FLOAT 0x000000f2
-#define G80_SURFACE_FORMAT_R8_UNORM 0x000000f3
-#define G80_SURFACE_FORMAT_R8_SNORM 0x000000f4
-#define G80_SURFACE_FORMAT_R8_SINT 0x000000f5
-#define G80_SURFACE_FORMAT_R8_UINT 0x000000f6
-#define G80_SURFACE_FORMAT_A8_UNORM 0x000000f7
-#define G80_SURFACE_FORMAT_BGR5_X1_UNORM 0x000000f8
-#define G80_SURFACE_FORMAT_RGBX8_UNORM 0x000000f9
-#define G80_SURFACE_FORMAT_RGBX8_SRGB 0x000000fa
-#define G80_SURFACE_FORMAT_BGR5_X1_UNORM_UNKFB 0x000000fb
-#define G80_SURFACE_FORMAT_BGR5_X1_UNORM_UNKFC 0x000000fc
-#define G80_SURFACE_FORMAT_BGRX8_UNORM_UNKFD 0x000000fd
-#define G80_SURFACE_FORMAT_BGRX8_UNORM_UNKFE 0x000000fe
-#define G80_SURFACE_FORMAT_Y32_UINT_UNKFF 0x000000ff
-#define G80_ZETA_FORMAT_Z32_FLOAT 0x0000000a
-#define G80_ZETA_FORMAT_Z16_UNORM 0x00000013
-#define G80_ZETA_FORMAT_S8_Z24_UNORM 0x00000014
-#define G80_ZETA_FORMAT_Z24_X8_UNORM 0x00000015
-#define G80_ZETA_FORMAT_Z24_S8_UNORM 0x00000016
-#define G80_ZETA_FORMAT_Z24_C8_UNORM 0x00000018
-#define G80_ZETA_FORMAT_Z32_S8_X24_FLOAT 0x00000019
-#define G80_ZETA_FORMAT_Z24_X8_S8_C8_X16_UNORM 0x0000001d
-#define G80_ZETA_FORMAT_Z32_X8_C8_X16_FLOAT 0x0000001e
-#define G80_ZETA_FORMAT_Z32_S8_C8_X16_FLOAT 0x0000001f
-#define GK104_IMAGE_FORMAT_RGBA32_FLOAT 0x00000002
-#define GK104_IMAGE_FORMAT_RGBA32_SINT 0x00000003
-#define GK104_IMAGE_FORMAT_RGBA32_UINT 0x00000004
-#define GK104_IMAGE_FORMAT_RGBA16_UNORM 0x00000008
-#define GK104_IMAGE_FORMAT_RGBA16_SNORM 0x00000009
-#define GK104_IMAGE_FORMAT_RGBA16_SINT 0x0000000a
-#define GK104_IMAGE_FORMAT_RGBA16_UINT 0x0000000b
-#define GK104_IMAGE_FORMAT_RGBA16_FLOAT 0x0000000c
-#define GK104_IMAGE_FORMAT_RG32_FLOAT 0x0000000d
-#define GK104_IMAGE_FORMAT_RG32_SINT 0x0000000e
-#define GK104_IMAGE_FORMAT_RG32_UINT 0x0000000f
-#define GK104_IMAGE_FORMAT_RGB10_A2_UNORM 0x00000013
-#define GK104_IMAGE_FORMAT_RGB10_A2_UINT 0x00000015
-#define GK104_IMAGE_FORMAT_RGBA8_UNORM 0x00000018
-#define GK104_IMAGE_FORMAT_RGBA8_SNORM 0x0000001a
-#define GK104_IMAGE_FORMAT_RGBA8_SINT 0x0000001b
-#define GK104_IMAGE_FORMAT_RGBA8_UINT 0x0000001c
-#define GK104_IMAGE_FORMAT_RG16_UNORM 0x0000001d
-#define GK104_IMAGE_FORMAT_RG16_SNORM 0x0000001e
-#define GK104_IMAGE_FORMAT_RG16_SINT 0x0000001f
-#define GK104_IMAGE_FORMAT_RG16_UINT 0x00000020
-#define GK104_IMAGE_FORMAT_RG16_FLOAT 0x00000021
-#define GK104_IMAGE_FORMAT_R11G11B10_FLOAT 0x00000024
-#define GK104_IMAGE_FORMAT_R32_SINT 0x00000027
-#define GK104_IMAGE_FORMAT_R32_UINT 0x00000028
-#define GK104_IMAGE_FORMAT_R32_FLOAT 0x00000029
-#define GK104_IMAGE_FORMAT_RG8_UNORM 0x0000002e
-#define GK104_IMAGE_FORMAT_RG8_SNORM 0x0000002f
-#define GK104_IMAGE_FORMAT_RG8_SINT 0x00000030
-#define GK104_IMAGE_FORMAT_RG8_UINT 0x00000031
-#define GK104_IMAGE_FORMAT_R16_UNORM 0x00000032
-#define GK104_IMAGE_FORMAT_R16_SNORM 0x00000033
-#define GK104_IMAGE_FORMAT_R16_SINT 0x00000034
-#define GK104_IMAGE_FORMAT_R16_UINT 0x00000035
-#define GK104_IMAGE_FORMAT_R16_FLOAT 0x00000036
-#define GK104_IMAGE_FORMAT_R8_UNORM 0x00000037
-#define GK104_IMAGE_FORMAT_R8_SNORM 0x00000038
-#define GK104_IMAGE_FORMAT_R8_SINT 0x00000039
-#define GK104_IMAGE_FORMAT_R8_UINT 0x0000003a
-#define G80_PGRAPH_DATA_ERROR_INVALID_OPERATION 0x00000003
-#define G80_PGRAPH_DATA_ERROR_INVALID_VALUE 0x00000004
-#define G80_PGRAPH_DATA_ERROR_INVALID_ENUM 0x00000005
-#define G80_PGRAPH_DATA_ERROR_INVALID_OBJECT 0x00000008
-#define G80_PGRAPH_DATA_ERROR_READ_ONLY_OBJECT 0x00000009
-#define G80_PGRAPH_DATA_ERROR_SUPERVISOR_OBJECT 0x0000000a
-#define G80_PGRAPH_DATA_ERROR_INVALID_ADDRESS_ALIGNMENT 0x0000000b
-#define G80_PGRAPH_DATA_ERROR_INVALID_BITFIELD 0x0000000c
-#define G80_PGRAPH_DATA_ERROR_BEGIN_END_ACTIVE 0x0000000d
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_COLOR_BACK_OVER_LIMIT 0x0000000e
-#define G80_PGRAPH_DATA_ERROR_VIEWPORT_ID_NEEDS_GP 0x0000000f
-#define G80_PGRAPH_DATA_ERROR_RT_DOUBLE_BIND 0x00000010
-#define G80_PGRAPH_DATA_ERROR_RT_TYPES_MISMATCH 0x00000011
-#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_ZETA 0x00000012
-#define G80_PGRAPH_DATA_ERROR_FP_TOO_FEW_REGS 0x00000015
-#define G80_PGRAPH_DATA_ERROR_ZETA_FORMAT_CSAA_MISMATCH 0x00000016
-#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_MSAA 0x00000017
-#define G80_PGRAPH_DATA_ERROR_FP_INTERPOLANT_START_OVER_LIMIT 0x00000018
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_LAYER_OVER_LIMIT 0x00000019
-#define G80_PGRAPH_DATA_ERROR_RT_INVALID_ALIGNMENT 0x0000001a
-#define G80_PGRAPH_DATA_ERROR_SAMPLER_OVER_LIMIT 0x0000001b
-#define G80_PGRAPH_DATA_ERROR_TEXTURE_OVER_LIMIT 0x0000001c
-#define G80_PGRAPH_DATA_ERROR_GP_TOO_MANY_OUTPUTS 0x0000001e
-#define G80_PGRAPH_DATA_ERROR_RT_BPP128_WITH_MS8 0x0000001f
-#define G80_PGRAPH_DATA_ERROR_Z_OUT_OF_BOUNDS 0x00000021
-#define G80_PGRAPH_DATA_ERROR_XY_OUT_OF_BOUNDS 0x00000023
-#define G80_PGRAPH_DATA_ERROR_VP_ZERO_INPUTS 0x00000024
-#define G80_PGRAPH_DATA_ERROR_CP_MORE_PARAMS_THAN_SHARED 0x00000027
-#define G80_PGRAPH_DATA_ERROR_CP_NO_REG_SPACE_STRIPED 0x00000028
-#define G80_PGRAPH_DATA_ERROR_CP_NO_REG_SPACE_PACKED 0x00000029
-#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_WARPS 0x0000002a
-#define G80_PGRAPH_DATA_ERROR_CP_BLOCK_SIZE_MISMATCH 0x0000002b
-#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_LOCAL_WARPS 0x0000002c
-#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_STACK_WARPS 0x0000002d
-#define G80_PGRAPH_DATA_ERROR_CP_NO_BLOCKDIM_LATCH 0x0000002e
-#define G80_PGRAPH_DATA_ERROR_ENG2D_FORMAT_MISMATCH 0x00000031
-#define G80_PGRAPH_DATA_ERROR_ENG2D_OPERATION_ILLEGAL_FOR_DST_FORMAT 0x00000033
-#define G80_PGRAPH_DATA_ERROR_ENG2D_FORMAT_MISMATCH_B 0x00000034
-#define G80_PGRAPH_DATA_ERROR_PRIMITIVE_ID_NEEDS_GP 0x0000003f
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_VIEWPORT_OVER_LIMIT 0x00000044
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_COLOR_FRONT_OVER_LIMIT 0x00000045
-#define G80_PGRAPH_DATA_ERROR_LAYER_ID_NEEDS_GP 0x00000046
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_CLIP_OVER_LIMIT 0x00000047
-#define G80_PGRAPH_DATA_ERROR_SEMANTIC_PTSZ_OVER_LIMIT 0x00000048
-#define G80_PGRAPH_DATA_ERROR_M2MF_LINE_LENGTH_EXCEEDS_PITCH_IN 0x00000051
-#define G80_PGRAPH_DATA_ERROR_M2MF_LINE_LENGTH_EXCEEDS_PITCH_OUT 0x00000053
-#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_ZETA_GF100 0x00000098
-#define G80_PGRAPH_DATA_ERROR_ENG2D_UNALIGNED_PITCH_GF100 0x000000a5
-#define G80_CG_IDLE_TIMEOUT__MASK 0x0000003f
-#define G80_CG_IDLE_TIMEOUT__SHIFT 0
-#define G80_CG_IDLE_TIMEOUT_ENABLE 0x00000040
-#define G80_CG_INTERFACE_REENABLE_TIME__MASK 0x000f0000
-#define G80_CG_INTERFACE_REENABLE_TIME__SHIFT 16
-#define G80_CG_THROTTLE_DUTY_M1__MASK 0x00f00000
-#define G80_CG_THROTTLE_DUTY_M1__SHIFT 20
-#define G80_CG_DELAY__MASK 0x0f000000
-#define G80_CG_DELAY__SHIFT 24
-#define G80_CG_CLOCK_THROTTLE_ENABLE 0x10000000
-#define G80_CG_THROTTLE_MODE__MASK 0x20000000
-#define G80_CG_THROTTLE_MODE__SHIFT 29
-#define G80_CG_THROTTLE_MODE_AUTO 0x00000000
-#define G80_CG_THROTTLE_MODE_MANUAL 0x20000000
-#define G80_CG_INTERFACE_THROTTLE_ENABLE 0x40000000
-#define G80_QUERY__SIZE 0x00000010
-#define G80_QUERY_COUNTER 0x00000000
-#define G80_QUERY_RES 0x00000004
+#define G80_VSTATUS_IDLE 0x00000000
+#define G80_VSTATUS_BUSY 0x00000001
+#define G80_VSTATUS_UNK2 0x00000002
+#define G80_VSTATUS_WAITING 0x00000003
+#define G80_VSTATUS_BLOCKED 0x00000005
+#define G80_VSTATUS_FAULTED 0x00000006
+#define G80_VSTATUS_PAUSED 0x00000007
+#define G80_SURFACE_FORMAT_BITMAP 0x0000001c
+#define G80_SURFACE_FORMAT_UNK1D 0x0000001d
+#define G80_SURFACE_FORMAT_RGBA32_FLOAT 0x000000c0
+#define G80_SURFACE_FORMAT_RGBA32_SINT 0x000000c1
+#define G80_SURFACE_FORMAT_RGBA32_UINT 0x000000c2
+#define G80_SURFACE_FORMAT_RGBX32_FLOAT 0x000000c3
+#define G80_SURFACE_FORMAT_RGBX32_SINT 0x000000c4
+#define G80_SURFACE_FORMAT_RGBX32_UINT 0x000000c5
+#define G80_SURFACE_FORMAT_RGBA16_UNORM 0x000000c6
+#define G80_SURFACE_FORMAT_RGBA16_SNORM 0x000000c7
+#define G80_SURFACE_FORMAT_RGBA16_SINT 0x000000c8
+#define G80_SURFACE_FORMAT_RGBA16_UINT 0x000000c9
+#define G80_SURFACE_FORMAT_RGBA16_FLOAT 0x000000ca
+#define G80_SURFACE_FORMAT_RG32_FLOAT 0x000000cb
+#define G80_SURFACE_FORMAT_RG32_SINT 0x000000cc
+#define G80_SURFACE_FORMAT_RG32_UINT 0x000000cd
+#define G80_SURFACE_FORMAT_RGBX16_FLOAT 0x000000ce
+#define G80_SURFACE_FORMAT_BGRA8_UNORM 0x000000cf
+#define G80_SURFACE_FORMAT_BGRA8_SRGB 0x000000d0
+#define G80_SURFACE_FORMAT_RGB10_A2_UNORM 0x000000d1
+#define G80_SURFACE_FORMAT_RGB10_A2_UINT 0x000000d2
+#define G80_SURFACE_FORMAT_RGBA8_UNORM 0x000000d5
+#define G80_SURFACE_FORMAT_RGBA8_SRGB 0x000000d6
+#define G80_SURFACE_FORMAT_RGBA8_SNORM 0x000000d7
+#define G80_SURFACE_FORMAT_RGBA8_SINT 0x000000d8
+#define G80_SURFACE_FORMAT_RGBA8_UINT 0x000000d9
+#define G80_SURFACE_FORMAT_RG16_UNORM 0x000000da
+#define G80_SURFACE_FORMAT_RG16_SNORM 0x000000db
+#define G80_SURFACE_FORMAT_RG16_SINT 0x000000dc
+#define G80_SURFACE_FORMAT_RG16_UINT 0x000000dd
+#define G80_SURFACE_FORMAT_RG16_FLOAT 0x000000de
+#define G80_SURFACE_FORMAT_BGR10_A2_UNORM 0x000000df
+#define G80_SURFACE_FORMAT_R11G11B10_FLOAT 0x000000e0
+#define G80_SURFACE_FORMAT_R32_SINT 0x000000e3
+#define G80_SURFACE_FORMAT_R32_UINT 0x000000e4
+#define G80_SURFACE_FORMAT_R32_FLOAT 0x000000e5
+#define G80_SURFACE_FORMAT_BGRX8_UNORM 0x000000e6
+#define G80_SURFACE_FORMAT_BGRX8_SRGB 0x000000e7
+#define G80_SURFACE_FORMAT_B5G6R5_UNORM 0x000000e8
+#define G80_SURFACE_FORMAT_BGR5_A1_UNORM 0x000000e9
+#define G80_SURFACE_FORMAT_RG8_UNORM 0x000000ea
+#define G80_SURFACE_FORMAT_RG8_SNORM 0x000000eb
+#define G80_SURFACE_FORMAT_RG8_SINT 0x000000ec
+#define G80_SURFACE_FORMAT_RG8_UINT 0x000000ed
+#define G80_SURFACE_FORMAT_R16_UNORM 0x000000ee
+#define G80_SURFACE_FORMAT_R16_SNORM 0x000000ef
+#define G80_SURFACE_FORMAT_R16_SINT 0x000000f0
+#define G80_SURFACE_FORMAT_R16_UINT 0x000000f1
+#define G80_SURFACE_FORMAT_R16_FLOAT 0x000000f2
+#define G80_SURFACE_FORMAT_R8_UNORM 0x000000f3
+#define G80_SURFACE_FORMAT_R8_SNORM 0x000000f4
+#define G80_SURFACE_FORMAT_R8_SINT 0x000000f5
+#define G80_SURFACE_FORMAT_R8_UINT 0x000000f6
+#define G80_SURFACE_FORMAT_A8_UNORM 0x000000f7
+#define G80_SURFACE_FORMAT_BGR5_X1_UNORM 0x000000f8
+#define G80_SURFACE_FORMAT_RGBX8_UNORM 0x000000f9
+#define G80_SURFACE_FORMAT_RGBX8_SRGB 0x000000fa
+#define G80_SURFACE_FORMAT_BGR5_X1_UNORM_UNKFB 0x000000fb
+#define G80_SURFACE_FORMAT_BGR5_X1_UNORM_UNKFC 0x000000fc
+#define G80_SURFACE_FORMAT_BGRX8_UNORM_UNKFD 0x000000fd
+#define G80_SURFACE_FORMAT_BGRX8_UNORM_UNKFE 0x000000fe
+#define G80_SURFACE_FORMAT_Y32_UINT_UNKFF 0x000000ff
+#define G80_ZETA_FORMAT_Z32_FLOAT 0x0000000a
+#define G80_ZETA_FORMAT_Z16_UNORM 0x00000013
+#define G80_ZETA_FORMAT_S8_Z24_UNORM 0x00000014
+#define G80_ZETA_FORMAT_Z24_X8_UNORM 0x00000015
+#define G80_ZETA_FORMAT_Z24_S8_UNORM 0x00000016
+#define G80_ZETA_FORMAT_Z24_C8_UNORM 0x00000018
+#define G80_ZETA_FORMAT_Z32_S8_X24_FLOAT 0x00000019
+#define G80_ZETA_FORMAT_Z24_X8_S8_C8_X16_UNORM 0x0000001d
+#define G80_ZETA_FORMAT_Z32_X8_C8_X16_FLOAT 0x0000001e
+#define G80_ZETA_FORMAT_Z32_S8_C8_X16_FLOAT 0x0000001f
+#define GK104_IMAGE_FORMAT_RGBA32_FLOAT 0x00000002
+#define GK104_IMAGE_FORMAT_RGBA32_SINT 0x00000003
+#define GK104_IMAGE_FORMAT_RGBA32_UINT 0x00000004
+#define GK104_IMAGE_FORMAT_RGBA16_UNORM 0x00000008
+#define GK104_IMAGE_FORMAT_RGBA16_SNORM 0x00000009
+#define GK104_IMAGE_FORMAT_RGBA16_SINT 0x0000000a
+#define GK104_IMAGE_FORMAT_RGBA16_UINT 0x0000000b
+#define GK104_IMAGE_FORMAT_RGBA16_FLOAT 0x0000000c
+#define GK104_IMAGE_FORMAT_RG32_FLOAT 0x0000000d
+#define GK104_IMAGE_FORMAT_RG32_SINT 0x0000000e
+#define GK104_IMAGE_FORMAT_RG32_UINT 0x0000000f
+#define GK104_IMAGE_FORMAT_RGB10_A2_UNORM 0x00000013
+#define GK104_IMAGE_FORMAT_RGB10_A2_UINT 0x00000015
+#define GK104_IMAGE_FORMAT_RGBA8_UNORM 0x00000018
+#define GK104_IMAGE_FORMAT_RGBA8_SNORM 0x0000001a
+#define GK104_IMAGE_FORMAT_RGBA8_SINT 0x0000001b
+#define GK104_IMAGE_FORMAT_RGBA8_UINT 0x0000001c
+#define GK104_IMAGE_FORMAT_RG16_UNORM 0x0000001d
+#define GK104_IMAGE_FORMAT_RG16_SNORM 0x0000001e
+#define GK104_IMAGE_FORMAT_RG16_SINT 0x0000001f
+#define GK104_IMAGE_FORMAT_RG16_UINT 0x00000020
+#define GK104_IMAGE_FORMAT_RG16_FLOAT 0x00000021
+#define GK104_IMAGE_FORMAT_R11G11B10_FLOAT 0x00000024
+#define GK104_IMAGE_FORMAT_R32_SINT 0x00000027
+#define GK104_IMAGE_FORMAT_R32_UINT 0x00000028
+#define GK104_IMAGE_FORMAT_R32_FLOAT 0x00000029
+#define GK104_IMAGE_FORMAT_RG8_UNORM 0x0000002e
+#define GK104_IMAGE_FORMAT_RG8_SNORM 0x0000002f
+#define GK104_IMAGE_FORMAT_RG8_SINT 0x00000030
+#define GK104_IMAGE_FORMAT_RG8_UINT 0x00000031
+#define GK104_IMAGE_FORMAT_R16_UNORM 0x00000032
+#define GK104_IMAGE_FORMAT_R16_SNORM 0x00000033
+#define GK104_IMAGE_FORMAT_R16_SINT 0x00000034
+#define GK104_IMAGE_FORMAT_R16_UINT 0x00000035
+#define GK104_IMAGE_FORMAT_R16_FLOAT 0x00000036
+#define GK104_IMAGE_FORMAT_R8_UNORM 0x00000037
+#define GK104_IMAGE_FORMAT_R8_SNORM 0x00000038
+#define GK104_IMAGE_FORMAT_R8_SINT 0x00000039
+#define GK104_IMAGE_FORMAT_R8_UINT 0x0000003a
+#define G80_PGRAPH_DATA_ERROR_INVALID_OPERATION 0x00000003
+#define G80_PGRAPH_DATA_ERROR_INVALID_VALUE 0x00000004
+#define G80_PGRAPH_DATA_ERROR_INVALID_ENUM 0x00000005
+#define G80_PGRAPH_DATA_ERROR_INVALID_OBJECT 0x00000008
+#define G80_PGRAPH_DATA_ERROR_READ_ONLY_OBJECT 0x00000009
+#define G80_PGRAPH_DATA_ERROR_SUPERVISOR_OBJECT 0x0000000a
+#define G80_PGRAPH_DATA_ERROR_INVALID_ADDRESS_ALIGNMENT 0x0000000b
+#define G80_PGRAPH_DATA_ERROR_INVALID_BITFIELD 0x0000000c
+#define G80_PGRAPH_DATA_ERROR_BEGIN_END_ACTIVE 0x0000000d
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_COLOR_BACK_OVER_LIMIT 0x0000000e
+#define G80_PGRAPH_DATA_ERROR_VIEWPORT_ID_NEEDS_GP 0x0000000f
+#define G80_PGRAPH_DATA_ERROR_RT_DOUBLE_BIND 0x00000010
+#define G80_PGRAPH_DATA_ERROR_RT_TYPES_MISMATCH 0x00000011
+#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_ZETA 0x00000012
+#define G80_PGRAPH_DATA_ERROR_FP_TOO_FEW_REGS 0x00000015
+#define G80_PGRAPH_DATA_ERROR_ZETA_FORMAT_CSAA_MISMATCH 0x00000016
+#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_MSAA 0x00000017
+#define G80_PGRAPH_DATA_ERROR_FP_INTERPOLANT_START_OVER_LIMIT 0x00000018
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_LAYER_OVER_LIMIT 0x00000019
+#define G80_PGRAPH_DATA_ERROR_RT_INVALID_ALIGNMENT 0x0000001a
+#define G80_PGRAPH_DATA_ERROR_SAMPLER_OVER_LIMIT 0x0000001b
+#define G80_PGRAPH_DATA_ERROR_TEXTURE_OVER_LIMIT 0x0000001c
+#define G80_PGRAPH_DATA_ERROR_GP_TOO_MANY_OUTPUTS 0x0000001e
+#define G80_PGRAPH_DATA_ERROR_RT_BPP128_WITH_MS8 0x0000001f
+#define G80_PGRAPH_DATA_ERROR_Z_OUT_OF_BOUNDS 0x00000021
+#define G80_PGRAPH_DATA_ERROR_XY_OUT_OF_BOUNDS 0x00000023
+#define G80_PGRAPH_DATA_ERROR_VP_ZERO_INPUTS 0x00000024
+#define G80_PGRAPH_DATA_ERROR_CP_MORE_PARAMS_THAN_SHARED 0x00000027
+#define G80_PGRAPH_DATA_ERROR_CP_NO_REG_SPACE_STRIPED 0x00000028
+#define G80_PGRAPH_DATA_ERROR_CP_NO_REG_SPACE_PACKED 0x00000029
+#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_WARPS 0x0000002a
+#define G80_PGRAPH_DATA_ERROR_CP_BLOCK_SIZE_MISMATCH 0x0000002b
+#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_LOCAL_WARPS 0x0000002c
+#define G80_PGRAPH_DATA_ERROR_CP_NOT_ENOUGH_STACK_WARPS 0x0000002d
+#define G80_PGRAPH_DATA_ERROR_CP_NO_BLOCKDIM_LATCH 0x0000002e
+#define G80_PGRAPH_DATA_ERROR_ENG2D_FORMAT_MISMATCH 0x00000031
+#define G80_PGRAPH_DATA_ERROR_ENG2D_OPERATION_ILLEGAL_FOR_DST_FORMAT 0x00000033
+#define G80_PGRAPH_DATA_ERROR_ENG2D_FORMAT_MISMATCH_B 0x00000034
+#define G80_PGRAPH_DATA_ERROR_PRIMITIVE_ID_NEEDS_GP 0x0000003f
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_VIEWPORT_OVER_LIMIT 0x00000044
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_COLOR_FRONT_OVER_LIMIT 0x00000045
+#define G80_PGRAPH_DATA_ERROR_LAYER_ID_NEEDS_GP 0x00000046
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_CLIP_OVER_LIMIT 0x00000047
+#define G80_PGRAPH_DATA_ERROR_SEMANTIC_PTSZ_OVER_LIMIT 0x00000048
+#define G80_PGRAPH_DATA_ERROR_M2MF_LINE_LENGTH_EXCEEDS_PITCH_IN 0x00000051
+#define G80_PGRAPH_DATA_ERROR_M2MF_LINE_LENGTH_EXCEEDS_PITCH_OUT 0x00000053
+#define G80_PGRAPH_DATA_ERROR_RT_LINEAR_WITH_ZETA_GF100 0x00000098
+#define G80_PGRAPH_DATA_ERROR_ENG2D_UNALIGNED_PITCH_GF100 0x000000a5
+#define G80_CG_IDLE_TIMEOUT__MASK 0x0000003f
+#define G80_CG_IDLE_TIMEOUT__SHIFT 0
+#define G80_CG_IDLE_TIMEOUT_ENABLE 0x00000040
+#define G80_CG_INTERFACE_REENABLE_TIME__MASK 0x000f0000
+#define G80_CG_INTERFACE_REENABLE_TIME__SHIFT 16
+#define G80_CG_THROTTLE_DUTY_M1__MASK 0x00f00000
+#define G80_CG_THROTTLE_DUTY_M1__SHIFT 20
+#define G80_CG_DELAY__MASK 0x0f000000
+#define G80_CG_DELAY__SHIFT 24
+#define G80_CG_CLOCK_THROTTLE_ENABLE 0x10000000
+#define G80_CG_THROTTLE_MODE__MASK 0x20000000
+#define G80_CG_THROTTLE_MODE__SHIFT 29
+#define G80_CG_THROTTLE_MODE_AUTO 0x00000000
+#define G80_CG_THROTTLE_MODE_MANUAL 0x20000000
+#define G80_CG_INTERFACE_THROTTLE_ENABLE 0x40000000
+#define G80_QUERY__SIZE 0x00000010
+#define G80_QUERY_COUNTER 0x00000000
+
+#define G80_QUERY_RES 0x00000004
+
+#define G80_QUERY_TIME 0x00000008
-#define G80_QUERY_TIME 0x00000008
#endif /* G80_DEFS_XML */
diff --git a/src/wld/nouveau/nouveau.c b/src/wld/nouveau/nouveau.c
deleted file mode 100644
index baed615..0000000
--- a/src/wld/nouveau/nouveau.c
+++ /dev/null
@@ -1,619 +0,0 @@
-/* wld: nouveau.c
- *
- * Copyright (c) 2013, 2014 Michael Forney
- *
- * Based in part upon nvc0_exa.c from xf86-video-nouveau, which is:
- *
- * Copyright 2007 NVIDIA, Corporation
- * Copyright 2008 Ben Skeggs
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in
- * all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-#include "g80_2d.xml.h"
-#include "g80_defs.xml.h"
-#include "nv_object.xml.h"
-#include "wld/drm-private.h"
-#include "wld/drm.h"
-#include "wld/pixman.h"
-
-#include <nouveau.h>
-#include <sys/mman.h>
-
-enum nv_architecture {
- NV_ARCH_50 = 0x50,
- NV_ARCH_C0 = 0xc0,
- NV_ARCH_E0 = 0xe0
-};
-
-struct nouveau_context {
- struct wld_context base;
- struct nouveau_device *device;
- struct nouveau_client *client;
- enum nv_architecture architecture;
-};
-
-struct nouveau_renderer {
- struct wld_renderer base;
- struct nouveau_object *channel;
- struct nouveau_pushbuf *pushbuf;
- struct nouveau_bufctx *bufctx;
- struct nouveau_object *nvc0_2d;
-
- struct nouveau_buffer *target;
-};
-
-struct nouveau_buffer {
- struct buffer base;
- struct wld_exporter exporter;
- struct nouveau_context *context;
- struct nouveau_bo *bo;
-};
-
-#include "../interface/buffer.h"
-#include "../interface/context.h"
-#include "../interface/renderer.h"
-#define DRM_DRIVER_NAME nouveau
-#include "../interface/drm.h"
-IMPL(nouveau_context, wld_context)
-IMPL(nouveau_renderer, wld_renderer)
-IMPL(nouveau_buffer, wld_buffer)
-
-/**** DRM driver ****/
-bool driver_device_supported(uint32_t vendor_id, uint32_t device_id) {
- return vendor_id == 0x10de;
-}
-
-struct wld_context *driver_create_context(int drm_fd) {
- struct nouveau_context *context;
-
- if (!(context = malloc(sizeof *context)))
- goto error0;
-
- if (nouveau_device_wrap(drm_fd, 0, &context->device) != 0)
- goto error1;
-
- switch (context->device->chipset & ~0xf) {
- /* TODO: Support NV50
- case 0x50:
- case 0x80:
- case 0x90:
- case 0xa0:
- context->architecture = NV_ARCH_50;
- break;
- */
- case 0xc0:
- case 0xd0:
- context->architecture = NV_ARCH_C0;
- break;
- /* TODO: Support NVE0
- case 0xe0:
- case 0xf0:
- case 0x100:
- context->architecture = NV_ARCH_E0;
- break;
- */
- default:
- return NULL;
- }
-
- if (nouveau_client_new(context->device, &context->client) != 0)
- goto error2;
-
- context_initialize(&context->base, &wld_context_impl);
-
- return &context->base;
-
-error2:
- nouveau_device_del(&context->device);
-error1:
- free(context);
-error0:
- return NULL;
-}
-
-/**** Context ****/
-static inline bool ensure_space(struct nouveau_pushbuf *push, uint32_t count) {
- if (push->end - push->cur > count)
- return true;
-
- return nouveau_pushbuf_space(push, count, 0, 0) == 0;
-}
-
-static inline void nv_add_dword(struct nouveau_pushbuf *push, uint32_t dword) {
- *push->cur++ = dword;
-}
-
-static inline void nv_add_dwords_va(struct nouveau_pushbuf *push,
- uint16_t count, va_list dwords) {
- while (count--)
- nv_add_dword(push, va_arg(dwords, uint32_t));
-}
-
-static inline void nv_add_data(struct nouveau_pushbuf *push, void *data,
- uint32_t count) {
- memcpy(push->cur, data, count * 4);
- push->cur += count;
-}
-
-static inline uint32_t nvc0_format(uint32_t format) {
- switch (format) {
- case WLD_FORMAT_XRGB8888:
- return G80_SURFACE_FORMAT_BGRX8_UNORM;
- case WLD_FORMAT_ARGB8888:
- return G80_SURFACE_FORMAT_BGRA8_UNORM;
- }
-
- return 0;
-}
-
-enum {
- GF100_COMMAND_TYPE_INCREASING = 1,
- GF100_COMMAND_TYPE_NON_INCREASING = 3,
- GF100_COMMAND_TYPE_INLINE = 4
-};
-
-enum {
- GF100_SUBCHANNEL_2D = 3,
-};
-
-static inline uint32_t nvc0_command(uint8_t type, uint8_t subchannel,
- uint16_t method, uint16_t count_or_value) {
- return type << 29 | count_or_value << 16 | subchannel << 13 | method >> 2;
-}
-
-static inline void nvc0_inline(struct nouveau_pushbuf *push, uint8_t subchannel,
- uint16_t method, uint16_t value) {
- nv_add_dword(
- push, nvc0_command(GF100_COMMAND_TYPE_INLINE, subchannel, method, value));
-}
-
-static inline void nvc0_methods(struct nouveau_pushbuf *push,
- uint8_t subchannel, uint16_t start_method,
- uint16_t count, ...) {
- va_list dwords;
- nv_add_dword(push, nvc0_command(GF100_COMMAND_TYPE_INCREASING, subchannel,
- start_method, count));
- va_start(dwords, count);
- nv_add_dwords_va(push, count, dwords);
- va_end(dwords);
-}
-
-#define nvc0_2d(push, method, count, ...) \
- nvc0_methods(push, GF100_SUBCHANNEL_2D, method, count, __VA_ARGS__)
-#define nvc0_2d_inline(push, method, value) \
- nvc0_inline(push, GF100_SUBCHANNEL_2D, method, value)
-
-static bool nvc0_2d_initialize(struct nouveau_renderer *renderer) {
- int ret;
-
- ret = nouveau_object_new(renderer->channel, GF100_2D, GF100_2D, NULL, 0,
- &renderer->nvc0_2d);
-
- if (ret != 0)
- goto error0;
-
- if (!ensure_space(renderer->pushbuf, 5))
- goto error1;
-
- nvc0_2d(renderer->pushbuf, NV1_SUBCHAN_OBJECT, 1, renderer->nvc0_2d->handle);
- nvc0_2d_inline(renderer->pushbuf, G80_2D_OPERATION,
- G80_2D_OPERATION_SRCCOPY_AND);
- nvc0_2d_inline(renderer->pushbuf, G80_2D_UNK0884, 0x3f);
- nvc0_2d_inline(renderer->pushbuf, G80_2D_UNK0888, 1);
-
- return true;
-
-error1:
- nouveau_object_del(&renderer->nvc0_2d);
-error0:
- return false;
-}
-
-static void nvc0_2d_finalize(struct nouveau_renderer *renderer) {
- nouveau_object_del(&renderer->nvc0_2d);
-}
-
-struct wld_renderer *context_create_renderer(struct wld_context *base) {
- struct nouveau_context *context = nouveau_context(base);
- struct nouveau_renderer *renderer;
- struct nvc0_fifo fifo = {};
- int ret;
-
- if (!(renderer = malloc(sizeof *renderer)))
- goto error0;
-
- ret = nouveau_object_new(&context->device->object, 0,
- NOUVEAU_FIFO_CHANNEL_CLASS, &fifo, sizeof fifo,
- &renderer->channel);
-
- if (ret != 0)
- goto error1;
-
- ret = nouveau_pushbuf_new(context->client, renderer->channel, 4, 32 * 1024,
- true, &renderer->pushbuf);
-
- if (ret != 0)
- goto error2;
-
- if (nouveau_bufctx_new(context->client, 1, &renderer->bufctx) != 0)
- goto error3;
-
- if (!nvc0_2d_initialize(renderer))
- goto error4;
-
- renderer_initialize(&renderer->base, &wld_renderer_impl);
- renderer->target = NULL;
-
- return &renderer->base;
-
-error4:
- nouveau_bufctx_del(&renderer->bufctx);
-error3:
- nouveau_pushbuf_del(&renderer->pushbuf);
-error2:
- nouveau_object_del(&renderer->channel);
-error1:
- free(renderer);
-error0:
- return NULL;
-}
-
-static bool export(struct wld_exporter *exporter, struct wld_buffer *base,
- uint32_t type, union wld_object *object) {
- struct nouveau_buffer *buffer = nouveau_buffer(base);
-
- switch (type) {
- case WLD_DRM_OBJECT_HANDLE:
- object->u32 = buffer->bo->handle;
- return true;
- case WLD_DRM_OBJECT_PRIME_FD:
- if (nouveau_bo_set_prime(buffer->bo, &object->i) != 0)
- return false;
- return true;
- default:
- return false;
- }
-}
-
-static struct nouveau_buffer *new_buffer(struct nouveau_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t pitch) {
- struct nouveau_buffer *buffer;
-
- if (!(buffer = malloc(sizeof *buffer)))
- return NULL;
-
- buffer_initialize(&buffer->base, &wld_buffer_impl, width, height, format,
- pitch);
- buffer->context = context;
- buffer->exporter.export = &export;
- wld_buffer_add_exporter(&buffer->base.base, &buffer->exporter);
-
- return buffer;
-}
-
-static inline uint32_t roundup(uint32_t value, uint32_t alignment) {
- return (value + alignment - 1) & ~(alignment - 1);
-}
-
-struct buffer *context_create_buffer(struct wld_context *base, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t flags) {
- struct nouveau_context *context = nouveau_context(base);
- struct nouveau_buffer *buffer;
- uint32_t bpp = format_bytes_per_pixel(format),
- pitch = roundup(width * bpp, 64), bo_flags;
- union nouveau_bo_config config = {};
-
- if (!(buffer = new_buffer(context, width, height, format, pitch)))
- goto error0;
-
- bo_flags = NOUVEAU_BO_VRAM;
-
- if (flags & WLD_DRM_FLAG_SCANOUT)
- bo_flags |= NOUVEAU_BO_CONTIG;
-
- if (height > 0x40 && !(flags & WLD_FLAG_MAP)) {
- config.nvc0.tile_mode = 0x40;
- config.nvc0.memtype = 0xfe;
- height = roundup(height, 0x80);
- } else
- bo_flags |= NOUVEAU_BO_MAP;
-
- if (nouveau_bo_new(context->device, bo_flags, 0, pitch * height, &config,
- &buffer->bo) != 0) {
- goto error1;
- }
-
- return &buffer->base;
-
-error1:
- free(buffer);
-error0:
- return NULL;
-}
-
-struct buffer *context_import_buffer(struct wld_context *base, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- struct nouveau_context *context = (void *)base;
- struct nouveau_buffer *buffer;
- struct nouveau_bo *bo = NULL;
-
- switch (type) {
- case WLD_DRM_OBJECT_PRIME_FD:
- if (nouveau_bo_prime_handle_ref(context->device, object.i, &bo) != 0) {
- goto error0;
- }
- break;
- default:
- goto error0;
- }
-
- if (!(buffer = new_buffer(context, width, height, format, pitch)))
- goto error1;
-
- buffer->bo = bo;
-
- return &buffer->base;
-
-error1:
- nouveau_bo_ref(NULL, &buffer->bo);
-error0:
- return NULL;
-}
-
-void context_destroy(struct wld_context *base) {
- struct nouveau_context *context = nouveau_context(base);
-
- nouveau_client_del(&context->client);
- nouveau_device_del(&context->device);
- free(context);
-}
-
-/**** Renderer ****/
-uint32_t renderer_capabilities(struct wld_renderer *renderer,
- struct buffer *buffer) {
- if (buffer->base.impl == &wld_buffer_impl)
- return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
-
- return 0;
-}
-
-bool renderer_set_target(struct wld_renderer *base, struct buffer *buffer) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
-
- if (buffer && buffer->base.impl != &wld_buffer_impl)
- return false;
-
- renderer->target = buffer ? nouveau_buffer(&buffer->base) : NULL;
-
- return true;
-}
-
-static inline void nvc0_2d_use_buffer(struct nouveau_renderer *renderer,
- struct nouveau_buffer *buffer,
- uint16_t format_method, uint16_t format) {
- uint32_t access = format == G80_2D_SRC_FORMAT ? NOUVEAU_BO_RD : NOUVEAU_BO_WR;
-
- nvc0_2d_inline(renderer->pushbuf, format_method, format);
-
- if (buffer->bo->config.nvc0.memtype) {
- nvc0_2d(renderer->pushbuf, format_method + 0x04, 2, 0,
- buffer->bo->config.nvc0.tile_mode);
- } else {
- nvc0_2d_inline(renderer->pushbuf, format_method + 0x04, 1);
- nvc0_2d(renderer->pushbuf, format_method + 0x14, 1,
- buffer->base.base.pitch);
- }
-
- nvc0_2d(renderer->pushbuf, format_method + 0x18, 4, buffer->base.base.width,
- buffer->base.base.height, buffer->bo->offset >> 32,
- buffer->bo->offset);
- nouveau_bufctx_refn(renderer->bufctx, 0, buffer->bo,
- NOUVEAU_BO_VRAM | access);
-}
-
-void renderer_fill_rectangle(struct wld_renderer *base, uint32_t color,
- int32_t x, int32_t y, uint32_t width,
- uint32_t height) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
- struct nouveau_buffer *dst = renderer->target;
- uint32_t format;
-
- if (!ensure_space(renderer->pushbuf, 18))
- return;
-
- format = nvc0_format(dst->base.base.format);
-
- nouveau_bufctx_reset(renderer->bufctx, 0);
- nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, format);
- nvc0_2d(renderer->pushbuf, G80_2D_DRAW_SHAPE, 3, G80_2D_DRAW_SHAPE_RECTANGLES,
- format, color);
- nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
-
- if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
- return;
-
- nvc0_2d(renderer->pushbuf, G80_2D_DRAW_POINT32_X(0), 4, x, y, x + width,
- y + height);
-}
-
-void renderer_copy_rectangle(struct wld_renderer *base,
- struct buffer *buffer_base, int32_t dst_x,
- int32_t dst_y, int32_t src_x, int32_t src_y,
- uint32_t width, uint32_t height) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
-
- if (buffer_base->base.impl != &wld_buffer_impl)
- return;
-
- struct nouveau_buffer *src = nouveau_buffer(&buffer_base->base),
- *dst = renderer->target;
- uint32_t src_format, dst_format;
-
- if (!ensure_space(renderer->pushbuf, 33))
- return;
-
- src_format = nvc0_format(src->base.base.format);
- dst_format = nvc0_format(dst->base.base.format);
-
- nouveau_bufctx_reset(renderer->bufctx, 0);
- nvc0_2d_use_buffer(renderer, src, G80_2D_SRC_FORMAT, src_format);
- nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, dst_format);
- nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
-
- if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
- return;
-
- nvc0_2d_inline(renderer->pushbuf, G80_GRAPH_SERIALIZE, 0);
- nvc0_2d_inline(renderer->pushbuf, G80_2D_BLIT_CONTROL,
- G80_2D_BLIT_CONTROL_ORIGIN_CENTER |
- G80_2D_BLIT_CONTROL_FILTER_POINT_SAMPLE);
- nvc0_2d(renderer->pushbuf, G80_2D_BLIT_DST_X, 12, dst_x, dst_y, width, height,
- 0, 1, 0, 1, 0, src_x, 0, src_y);
-
- renderer_flush(base);
-}
-
-void renderer_draw_text(struct wld_renderer *base, struct font *font,
- uint32_t color, int32_t x, int32_t y, const char *text,
- uint32_t length, struct wld_extents *extents) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
- struct nouveau_buffer *dst = renderer->target;
- uint32_t format;
- int ret;
- struct glyph *glyph;
- FT_UInt glyph_index;
- uint32_t c, count;
- int32_t origin_x = x;
-
- if (!ensure_space(renderer->pushbuf, 17))
- return;
-
- format = nvc0_format(dst->base.base.format);
-
- nouveau_bufctx_reset(renderer->bufctx, 0);
- nvc0_2d_use_buffer(renderer, dst, G80_2D_DST_FORMAT, format);
- nvc0_2d_inline(renderer->pushbuf, G80_2D_SIFC_BITMAP_ENABLE, 1);
- nvc0_2d(renderer->pushbuf, G80_2D_SIFC_BITMAP_FORMAT, 6,
- G80_2D_SIFC_BITMAP_FORMAT_I1, 0, /* SIFC_FORMAT */
- G80_2D_SIFC_BITMAP_LINE_PACK_MODE_ALIGN_BYTE, 0,
- color, /* SIFC_BITMAP_COLOR_BIT0, SIFC_BITMAP_COLOR_BIT1 */
- 0 /* SIFC_BITMAP_WRITE_BIT0_ENABLE */
- );
- nouveau_pushbuf_bufctx(renderer->pushbuf, renderer->bufctx);
-
- if (nouveau_pushbuf_validate(renderer->pushbuf) != 0)
- return;
-
- if (length == -1)
- length = strlen(text);
-
- while ((ret = FcUtf8ToUcs4((FcChar8 *)text, &c, length)) > 0 && c != '\0') {
- text += ret;
- length -= ret;
- glyph_index = FT_Get_Char_Index(font->face, c);
-
- if (!font_ensure_glyph(font, glyph_index))
- continue;
-
- glyph = font->glyphs[glyph_index];
-
- if (glyph->bitmap.width == 0 || glyph->bitmap.rows == 0)
- goto advance;
-
- count = (glyph->bitmap.pitch * glyph->bitmap.rows + 3) / 4;
-
- if (!ensure_space(renderer->pushbuf, 12 + count))
- return;
-
- nvc0_2d(renderer->pushbuf, G80_2D_SIFC_WIDTH, 10,
- /* Use the pitch instead of width to ensure the correct
- * alignment is used. */
- glyph->bitmap.pitch * 8, glyph->bitmap.rows, 0, 1, 0, 1, 0,
- origin_x + glyph->x, 0, y + glyph->y);
- nv_add_dword(renderer->pushbuf,
- nvc0_command(GF100_COMMAND_TYPE_NON_INCREASING,
- GF100_SUBCHANNEL_2D, G80_2D_SIFC_DATA, count));
- nv_add_data(renderer->pushbuf, glyph->bitmap.buffer, count);
-
- advance:
- origin_x += glyph->advance;
- }
-
- if (extents)
- extents->advance = origin_x - x;
-}
-
-void renderer_flush(struct wld_renderer *base) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
-
- nouveau_pushbuf_kick(renderer->pushbuf, renderer->channel);
- nouveau_pushbuf_bufctx(renderer->pushbuf, NULL);
-}
-
-void renderer_destroy(struct wld_renderer *base) {
- struct nouveau_renderer *renderer = nouveau_renderer(base);
-
- nvc0_2d_finalize(renderer);
- nouveau_bufctx_del(&renderer->bufctx);
- nouveau_pushbuf_del(&renderer->pushbuf);
- nouveau_object_del(&renderer->channel);
- free(renderer);
-}
-
-/**** Buffer ****/
-bool buffer_map(struct buffer *base) {
- struct nouveau_buffer *buffer = nouveau_buffer(&base->base);
-
- /* If the buffer is tiled, it cannot be mapped into virtual memory in order
- * to appear linear like intel can do with map_gtt. */
- if (buffer->bo->config.nvc0.tile_mode)
- return false;
-
- if (nouveau_bo_map(buffer->bo, NOUVEAU_BO_WR, buffer->context->client) != 0) {
- return false;
- }
-
- buffer->base.base.map = buffer->bo->map;
-
- return true;
-}
-
-bool buffer_unmap(struct buffer *base) {
- struct nouveau_buffer *buffer = nouveau_buffer(&base->base);
-
- if (munmap(buffer->bo->map, buffer->bo->size) == -1)
- return false;
-
- buffer->bo->map = NULL;
- base->base.map = NULL;
-
- return true;
-}
-
-void buffer_destroy(struct buffer *base) {
- struct nouveau_buffer *buffer = nouveau_buffer(&base->base);
-
- nouveau_bo_ref(NULL, &buffer->bo);
- free(buffer);
-}
diff --git a/src/wld/nouveau/nv_object.xml.h b/src/wld/nouveau/nv_object.xml.h
index 08ba714..0a12a19 100644
--- a/src/wld/nouveau/nv_object.xml.h
+++ b/src/wld/nouveau/nv_object.xml.h
@@ -3,255 +3,133 @@
/* Autogenerated file, DO NOT EDIT manually!
-This file was generated by the rules-ng-ng headergen tool in this git
-repository: http://github.com/envytools/envytools/ git clone
-https://github.com/envytools/envytools.git
+This file was generated by the rules-ng-ng headergen tool in this git repository:
+http://github.com/envytools/envytools/
+git clone https://github.com/envytools/envytools.git
The rules-ng-ng source files this header was generated from are:
-- /home/michael/src/envytools/rnndb/root.xml ( 514
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/copyright.xml ( 6452
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/falcon.xml ( 17092
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244
-bytes, from 2014-11-02 20:39:42)
-- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682
-bytes, from 2014-11-02 20:39:43)
-- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411
-bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/root.xml ( 514 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/copyright.xml ( 6452 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv_mmio.xml ( 7175 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nvchipsets.xml ( 2759 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pmc.xml ( 11361 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pbus.xml ( 19778 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/g80_defs.xml ( 18175 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_vm.xml ( 9832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_vga.xml ( 13101 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pci.xml ( 17513 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv1_pfifo.xml ( 10542 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv4_pfifo.xml ( 24010 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/g80_pfifo.xml ( 23184 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/gf100_pfifo.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_vm.xml ( 8722 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/nv40_pclock.xml ( 1166 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/g80_pclock.xml ( 16434 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/gt215_pclock.xml ( 4960 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv10_pvideo.xml ( 2468 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/ptimer.xml ( 2285 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv10_pcounter.xml ( 5914 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv40_pcounter.xml ( 9663 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pmpeg.xml ( 12735 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvpe.xml ( 703 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_fifo.xml ( 2614 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/nv_object.xml ( 15326 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pme.xml ( 5105 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/nv17_ptv.xml ( 457 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pnvio.xml ( 31893 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/pvp1.xml ( 2108 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pvp2.xml ( 1615 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/xtensa.xml ( 5390 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/ptherm.xml ( 34788 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/bus/pfuse.xml ( 1158 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/punits.xml ( 4661 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pvld.xml ( 13271 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/falcon.xml ( 17092 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/falcon_crypt.xml ( 3446 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp3/ppdec.xml ( 14150 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/pppp.xml ( 8842 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/nv_defs.xml ( 4399 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp3/psec.xml ( 993 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/g84_punk089.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_prmvio.xml ( 651 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pdma.xml ( 5339 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv3_pfb.xml ( 4493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv10_pfb.xml ( 18821 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv_pfb.xml ( 1135 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/g80_pfb.xml ( 11139 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pffb.xml ( 2712 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pstraps.xml ( 8118 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pcipher.xml ( 3572 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/pbsp.xml ( 10610 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/pcopy.xml ( 7877 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pcodec.xml ( 449 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/gt215_pkfuse.xml ( 448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/pdaemon.xml ( 19259 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/pm/10e000.xml ( 1185 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pbfb.xml ( 3917 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/pibus.xml ( 8545 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/pm/gf100_pclock.xml ( 7338 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/memory/gf100_pp2p.xml ( 1949 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pxbar.xml ( 1516 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/gf100_pmfb.xml ( 3646 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/gf100_pcounter.xml ( 12713 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/pvcomp.xml ( 8687 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/pvenc.xml ( 1416 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/display/gf119_punk1c3.xml ( 981 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pmedia.xml ( 432 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/nv1_paudio.xml ( 1862 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/ad1848.xml ( 5260 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_pgraph.xml ( 14207 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv1_2d.xml ( 36532 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pgraph.xml ( 4004 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_pgraph.xml ( 11327 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/pgraph.xml ( 31568 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/tpc.xml ( 6832 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mpc.xml ( 6373 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_pgraph/mp.xml ( 16762 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/pgraph.xml ( 26735 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/hw_blk.xml ( 760 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ctxctl.xml ( 13155 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/gpc.xml ( 13114 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/tpc.xml ( 22154 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/ppc.xml ( 2131 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_pgraph/rop.xml ( 5134 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_pdma.xml ( 2290 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pfb.xml ( 4030 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pcrtc.xml ( 1108 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/memory/nv1_pram.xml ( 1235 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/pchipid.xml ( 493 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv1_pdac.xml ( 4628 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/io/peeprom.xml ( 702 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv3_pramdac.xml ( 4419 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/g80_pdisplay.xml ( 39075 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/bus/prm.xml ( 5094 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/display/nv_evo.xml ( 10448 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/fifo/nv_objects.xml ( 1053 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_m2mf.xml ( 2691 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_m2mf.xml ( 2783 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_dvd.xml ( 2994 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv3_3d.xml ( 5197 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv4_3d.xml ( 17716 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv_3ddefs.xml ( 16390 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv10_3d.xml ( 18416 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv20_3d.xml ( 21096 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/nv30-40_3d.xml ( 32451 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_2d.xml ( 11440 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_3d.xml ( 65900 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_compute.xml ( 14027 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_3d.xml ( 59845 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_p2mf.xml ( 2376 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_compute.xml ( 11143 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gk104_compute.xml ( 10182 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/me_fifo.xml ( 1685 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vpe/vp1_fifo.xml ( 670 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/vdec/vp2/cipher_fifo.xml ( 2071 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/fifo/gk104_copy.xml ( 3938 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/g80_texture.xml ( 8881 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/graph/gf100_shaders.xml ( 9244 bytes, from 2014-11-02 20:39:42)
+- /home/michael/src/envytools/rnndb/vdec/vpe/mpeg_cmd.xml ( 7682 bytes, from 2014-11-02 20:39:43)
+- /home/michael/src/envytools/rnndb/extdev/adt7473.xml ( 11411 bytes, from 2014-11-02 20:39:42)
Copyright (C) 2006-2014 by the following authors:
- Artur Huillet <arthur.huillet@free.fr> (ahuillet)
@@ -311,262 +189,264 @@ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
*/
-#define NV1_DMA_FROM_MEMORY 0x00000002
-#define NV1_DMA_TO_MEMORY 0x00000003
-#define NV1_NULL 0x00000030
-#define NV3_DMA_IN_MEMORY 0x0000003d
-#define NV1_OP_CLIP 0x00000010
-#define NV1_OP_BLEND_AND 0x00000011
-#define NV1_BETA 0x00000012
-#define NV4_BETA4 0x00000072
-#define NV1_OP_ROP_AND 0x00000013
-#define NV1_ROP 0x00000014
-#define NV3_ROP 0x00000043
-#define NV1_OP_CHROMA 0x00000015
-#define NV1_OP_PLANE_SWITCH 0x00000016
-#define NV1_CHROMA 0x00000017
-#define NV4_CHROMA 0x00000057
-#define NV1_PATTERN 0x00000018
-#define NV4_PATTERN 0x00000044
-#define NV1_CLIP 0x00000019
-#define NV1_OP_SRCCOPY_AND 0x00000064
-#define NV3_OP_SRCCOPY 0x00000065
-#define NV4_OP_SRCCOPY_PREMULT 0x00000066
-#define NV4_OP_BLEND_PREMULT 0x00000067
-#define NV1_POINT 0x0000001a
-#define NV1_LINE 0x0000001b
-#define NV1_LIN 0x0000001c
-#define NV4_LIN 0x0000005c
-#define NV30_LIN 0x0000035c
-#define NV40_LIN 0x0000305c
-#define NV1_TRI 0x0000001d
-#define NV4_TRI 0x0000005d
-#define NV1_RECT 0x0000001e
-#define NV4_RECT 0x0000005e
-#define NV1_BLIT 0x0000001f
-#define NV4_BLIT 0x0000005f
-#define NV15_BLIT 0x0000009f
-#define NV1_IFM 0x00000020
-#define NV1_IFC 0x00000021
-#define NV4_IFC 0x00000061
-#define NV5_IFC 0x00000065
-#define NV10_IFC 0x0000008a
-#define NV30_IFC 0x0000038a
-#define NV40_IFC 0x0000308a
-#define NV1_BITMAP 0x00000022
-#define NV1_ITM 0x00000025
-#define NV3_SIFC 0x00000036
-#define NV4_SIFC 0x00000076
-#define NV5_SIFC 0x00000066
-#define NV30_SIFC 0x00000366
-#define NV40_SIFC 0x00003066
-#define NV3_SIFM 0x00000037
-#define NV4_SIFM 0x00000077
-#define NV5_SIFM 0x00000063
-#define NV10_SIFM 0x00000089
-#define NV30_SIFM 0x00000389
-#define NV40_SIFM 0x00003089
-#define G80_SIFM 0x00005089
-#define NV3_GDI 0x0000004b
-#define NV4_GDI 0x0000004a
-#define NV4_SURFACE_SWZ 0x00000052
-#define NV20_SURFACE_SWZ 0x0000009e
-#define NV30_SURFACE_SWZ 0x0000039e
-#define NV40_SURFACE_SWZ 0x0000309e
-#define NV3_SURFACE_DST 0x00000058
-#define NV3_SURFACE_SRC 0x00000059
-#define NV4_SURFACE_2D 0x00000042
-#define NV10_SURFACE_2D 0x00000062
-#define NV30_SURFACE_2D 0x00000362
-#define NV40_SURFACE_2D 0x00003062
-#define G80_SURFACE_2D 0x00005062
-#define NV4_INDEX 0x00000060
-#define NV5_INDEX 0x00000064
-#define NV30_INDEX 0x00000364
-#define NV40_INDEX 0x00003064
-#define NV10_TEXUPLOAD 0x0000007b
-#define NV30_TEXUPLOAD 0x0000037b
-#define NV40_TEXUPLOAD 0x0000307b
-#define NV1_TEXLIN 0x00000023
-#define NV1_TEXQUAD 0x00000024
-#define NV1_TEXLINBETA 0x00000034
-#define NV1_TEXQUADBETA 0x00000035
-#define NV4_DVD_SUBPICTURE 0x00000038
-#define NV10_DVD_SUBPICTURE 0x00000088
-#define NV3_M2MF 0x00000039
-#define G80_M2MF 0x00005039
-#define GF100_M2MF 0x00009039
-#define GK104_P2MF 0x0000a040
-#define GK110_P2MF 0x0000a140
-#define NV3_SURFACE_COLOR 0x0000005a
-#define NV3_SURFACE_ZETA 0x0000005b
-#define NV3_TEXTURED_TRIANGLE 0x00000048
-#define NV4_TEXTURED_TRIANGLE 0x00000054
-#define NV10_TEXTURED_TRIANGLE 0x00000094
-#define NV4_SURFACE_3D 0x00000053
-#define NV10_SURFACE_3D 0x00000093
-#define NV4_MULTITEX_TRIANGLE 0x00000055
-#define NV10_MULTITEX_TRIANGLE 0x00000095
-#define NV10_3D 0x00000056
-#define NV15_3D 0x00000096
-#define NV11_3D 0x00000098
-#define NV17_3D 0x00000099
-#define NV20_3D 0x00000097
-#define NV25_3D 0x00000597
-#define NV30_3D 0x00000397
-#define NV35_3D 0x00000497
-#define NV34_3D 0x00000697
-#define NV40_3D 0x00004097
-#define NV44_3D 0x00004497
-#define G80_3D 0x00005097
-#define G84_3D 0x00008297
-#define G200_3D 0x00008397
-#define GT215_3D 0x00008597
-#define MCP89_3D 0x00008697
-#define GF100_3D 0x00009097
-#define GF108_3D 0x00009197
-#define GF110_3D 0x00009297
-#define GK104_3D 0x0000a097
-#define GK110_3D 0x0000a197
-#define GK20A_3D 0x0000a297
-#define GM107_3D 0x0000b097
-#define G80_2D 0x0000502d
-#define GF100_2D 0x0000902d
-#define G80_COMPUTE 0x000050c0
-#define GT215_COMPUTE 0x000085c0
-#define GF100_COMPUTE 0x000090c0
-#define GF110_COMPUTE 0x000091c0
-#define GK104_COMPUTE 0x0000a0c0
-#define GK110_COMPUTE 0x0000a1c0
-#define GM107_COMPUTE 0x0000b0c0
-#define G84_CIPHER 0x000074c1
-#define GK104_COPY 0x0000a0b5
-#define GM107_COPY 0x0000b0b5
-#define NV31_MPEG 0x00003174
-#define G84_MPEG 0x00008274
-#define NV40_ME 0x00004075
-#define NV41_VP1 0x00004176
-#define SUBCHAN__SIZE 0x00008000
-#define NV1_SUBCHAN 0x00000000
-
-#define NV1_SUBCHAN_OBJECT 0x00000000
-
-#define GF100_SUBCHAN_NOP 0x00000008
-
-#define G84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH 0x00000010
-
-#define G84_SUBCHAN_SEMAPHORE_ADDRESS_LOW 0x00000014
-
-#define G84_SUBCHAN_SEMAPHORE_SEQUENCE 0x00000018
-
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER 0x0000001c
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION__MASK 0x0000000f
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION__SHIFT 0
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_EQUAL 0x00000001
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_RELEASE 0x00000002
-#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_GEQUAL 0x00000004
-#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_MASK 0x00000008
-#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_YIELD 0x00001000
-#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_UNK20 0x00100000
-#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_SHORT 0x01000000
-
-#define G84_SUBCHAN_NOTIFY_INTR 0x00000020
-
-#define G84_SUBCHAN_WRCACHE_FLUSH 0x00000024
-
-#define MCP89_SUBCHAN_UNK28 0x00000028
-
-#define MCP89_SUBCHAN_UNK2C 0x0000002c
-#define MCP89_SUBCHAN_UNK2C_UNK0__MASK 0x0fffffff
-#define MCP89_SUBCHAN_UNK2C_UNK0__SHIFT 0
-#define MCP89_SUBCHAN_UNK2C_UNK28 0x10000000
-#define MCP89_SUBCHAN_UNK2C_UNK29__MASK 0xe0000000
-#define MCP89_SUBCHAN_UNK2C_UNK29__SHIFT 29
-#define MCP89_SUBCHAN_UNK2C_UNK29_UNK0 0x00000000
-#define MCP89_SUBCHAN_UNK2C_UNK29_UNK1 0x20000000
-#define MCP89_SUBCHAN_UNK2C_UNK29_UNK2 0x40000000
-
-#define NV10_SUBCHAN_REF_CNT 0x00000050
-
-#define NV1A_SUBCHAN_DMA_SEMAPHORE 0x00000060
-#define NV1A_SUBCHAN_SEMAPHORE_OFFSET 0x00000064
+#define NV1_DMA_FROM_MEMORY 0x00000002
+#define NV1_DMA_TO_MEMORY 0x00000003
+#define NV1_NULL 0x00000030
+#define NV3_DMA_IN_MEMORY 0x0000003d
+#define NV1_OP_CLIP 0x00000010
+#define NV1_OP_BLEND_AND 0x00000011
+#define NV1_BETA 0x00000012
+#define NV4_BETA4 0x00000072
+#define NV1_OP_ROP_AND 0x00000013
+#define NV1_ROP 0x00000014
+#define NV3_ROP 0x00000043
+#define NV1_OP_CHROMA 0x00000015
+#define NV1_OP_PLANE_SWITCH 0x00000016
+#define NV1_CHROMA 0x00000017
+#define NV4_CHROMA 0x00000057
+#define NV1_PATTERN 0x00000018
+#define NV4_PATTERN 0x00000044
+#define NV1_CLIP 0x00000019
+#define NV1_OP_SRCCOPY_AND 0x00000064
+#define NV3_OP_SRCCOPY 0x00000065
+#define NV4_OP_SRCCOPY_PREMULT 0x00000066
+#define NV4_OP_BLEND_PREMULT 0x00000067
+#define NV1_POINT 0x0000001a
+#define NV1_LINE 0x0000001b
+#define NV1_LIN 0x0000001c
+#define NV4_LIN 0x0000005c
+#define NV30_LIN 0x0000035c
+#define NV40_LIN 0x0000305c
+#define NV1_TRI 0x0000001d
+#define NV4_TRI 0x0000005d
+#define NV1_RECT 0x0000001e
+#define NV4_RECT 0x0000005e
+#define NV1_BLIT 0x0000001f
+#define NV4_BLIT 0x0000005f
+#define NV15_BLIT 0x0000009f
+#define NV1_IFM 0x00000020
+#define NV1_IFC 0x00000021
+#define NV4_IFC 0x00000061
+#define NV5_IFC 0x00000065
+#define NV10_IFC 0x0000008a
+#define NV30_IFC 0x0000038a
+#define NV40_IFC 0x0000308a
+#define NV1_BITMAP 0x00000022
+#define NV1_ITM 0x00000025
+#define NV3_SIFC 0x00000036
+#define NV4_SIFC 0x00000076
+#define NV5_SIFC 0x00000066
+#define NV30_SIFC 0x00000366
+#define NV40_SIFC 0x00003066
+#define NV3_SIFM 0x00000037
+#define NV4_SIFM 0x00000077
+#define NV5_SIFM 0x00000063
+#define NV10_SIFM 0x00000089
+#define NV30_SIFM 0x00000389
+#define NV40_SIFM 0x00003089
+#define G80_SIFM 0x00005089
+#define NV3_GDI 0x0000004b
+#define NV4_GDI 0x0000004a
+#define NV4_SURFACE_SWZ 0x00000052
+#define NV20_SURFACE_SWZ 0x0000009e
+#define NV30_SURFACE_SWZ 0x0000039e
+#define NV40_SURFACE_SWZ 0x0000309e
+#define NV3_SURFACE_DST 0x00000058
+#define NV3_SURFACE_SRC 0x00000059
+#define NV4_SURFACE_2D 0x00000042
+#define NV10_SURFACE_2D 0x00000062
+#define NV30_SURFACE_2D 0x00000362
+#define NV40_SURFACE_2D 0x00003062
+#define G80_SURFACE_2D 0x00005062
+#define NV4_INDEX 0x00000060
+#define NV5_INDEX 0x00000064
+#define NV30_INDEX 0x00000364
+#define NV40_INDEX 0x00003064
+#define NV10_TEXUPLOAD 0x0000007b
+#define NV30_TEXUPLOAD 0x0000037b
+#define NV40_TEXUPLOAD 0x0000307b
+#define NV1_TEXLIN 0x00000023
+#define NV1_TEXQUAD 0x00000024
+#define NV1_TEXLINBETA 0x00000034
+#define NV1_TEXQUADBETA 0x00000035
+#define NV4_DVD_SUBPICTURE 0x00000038
+#define NV10_DVD_SUBPICTURE 0x00000088
+#define NV3_M2MF 0x00000039
+#define G80_M2MF 0x00005039
+#define GF100_M2MF 0x00009039
+#define GK104_P2MF 0x0000a040
+#define GK110_P2MF 0x0000a140
+#define NV3_SURFACE_COLOR 0x0000005a
+#define NV3_SURFACE_ZETA 0x0000005b
+#define NV3_TEXTURED_TRIANGLE 0x00000048
+#define NV4_TEXTURED_TRIANGLE 0x00000054
+#define NV10_TEXTURED_TRIANGLE 0x00000094
+#define NV4_SURFACE_3D 0x00000053
+#define NV10_SURFACE_3D 0x00000093
+#define NV4_MULTITEX_TRIANGLE 0x00000055
+#define NV10_MULTITEX_TRIANGLE 0x00000095
+#define NV10_3D 0x00000056
+#define NV15_3D 0x00000096
+#define NV11_3D 0x00000098
+#define NV17_3D 0x00000099
+#define NV20_3D 0x00000097
+#define NV25_3D 0x00000597
+#define NV30_3D 0x00000397
+#define NV35_3D 0x00000497
+#define NV34_3D 0x00000697
+#define NV40_3D 0x00004097
+#define NV44_3D 0x00004497
+#define G80_3D 0x00005097
+#define G84_3D 0x00008297
+#define G200_3D 0x00008397
+#define GT215_3D 0x00008597
+#define MCP89_3D 0x00008697
+#define GF100_3D 0x00009097
+#define GF108_3D 0x00009197
+#define GF110_3D 0x00009297
+#define GK104_3D 0x0000a097
+#define GK110_3D 0x0000a197
+#define GK20A_3D 0x0000a297
+#define GM107_3D 0x0000b097
+#define G80_2D 0x0000502d
+#define GF100_2D 0x0000902d
+#define G80_COMPUTE 0x000050c0
+#define GT215_COMPUTE 0x000085c0
+#define GF100_COMPUTE 0x000090c0
+#define GF110_COMPUTE 0x000091c0
+#define GK104_COMPUTE 0x0000a0c0
+#define GK110_COMPUTE 0x0000a1c0
+#define GM107_COMPUTE 0x0000b0c0
+#define G84_CIPHER 0x000074c1
+#define GK104_COPY 0x0000a0b5
+#define GM107_COPY 0x0000b0b5
+#define NV31_MPEG 0x00003174
+#define G84_MPEG 0x00008274
+#define NV40_ME 0x00004075
+#define NV41_VP1 0x00004176
+#define SUBCHAN__SIZE 0x00008000
+#define NV1_SUBCHAN 0x00000000
+
+#define NV1_SUBCHAN_OBJECT 0x00000000
+
+#define GF100_SUBCHAN_NOP 0x00000008
+
+#define G84_SUBCHAN_SEMAPHORE_ADDRESS_HIGH 0x00000010
+
+#define G84_SUBCHAN_SEMAPHORE_ADDRESS_LOW 0x00000014
+
+#define G84_SUBCHAN_SEMAPHORE_SEQUENCE 0x00000018
+
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER 0x0000001c
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION__MASK 0x0000000f
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION__SHIFT 0
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_EQUAL 0x00000001
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_RELEASE 0x00000002
+#define G84_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_GEQUAL 0x00000004
+#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_ACTION_ACQUIRE_MASK 0x00000008
+#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_YIELD 0x00001000
+#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_UNK20 0x00100000
+#define GF100_SUBCHAN_SEMAPHORE_TRIGGER_SHORT 0x01000000
+
+#define G84_SUBCHAN_NOTIFY_INTR 0x00000020
+
+#define G84_SUBCHAN_WRCACHE_FLUSH 0x00000024
+
+#define MCP89_SUBCHAN_UNK28 0x00000028
+
+#define MCP89_SUBCHAN_UNK2C 0x0000002c
+#define MCP89_SUBCHAN_UNK2C_UNK0__MASK 0x0fffffff
+#define MCP89_SUBCHAN_UNK2C_UNK0__SHIFT 0
+#define MCP89_SUBCHAN_UNK2C_UNK28 0x10000000
+#define MCP89_SUBCHAN_UNK2C_UNK29__MASK 0xe0000000
+#define MCP89_SUBCHAN_UNK2C_UNK29__SHIFT 29
+#define MCP89_SUBCHAN_UNK2C_UNK29_UNK0 0x00000000
+#define MCP89_SUBCHAN_UNK2C_UNK29_UNK1 0x20000000
+#define MCP89_SUBCHAN_UNK2C_UNK29_UNK2 0x40000000
+
+#define NV10_SUBCHAN_REF_CNT 0x00000050
-#define NV1A_SUBCHAN_SEMAPHORE_ACQUIRE 0x00000068
+#define NV1A_SUBCHAN_DMA_SEMAPHORE 0x00000060
-#define NV1A_SUBCHAN_SEMAPHORE_RELEASE 0x0000006c
+#define NV1A_SUBCHAN_SEMAPHORE_OFFSET 0x00000064
-#define GF100_SUBCHAN_UNK70 0x00000070
+#define NV1A_SUBCHAN_SEMAPHORE_ACQUIRE 0x00000068
-#define GF100_SUBCHAN_UNK74 0x00000074
+#define NV1A_SUBCHAN_SEMAPHORE_RELEASE 0x0000006c
-#define GF100_SUBCHAN_UNK78 0x00000078
+#define GF100_SUBCHAN_UNK70 0x00000070
-#define GF100_SUBCHAN_UNK7C 0x0000007c
+#define GF100_SUBCHAN_UNK74 0x00000074
-#define NV40_SUBCHAN_YIELD 0x00000080
+#define GF100_SUBCHAN_UNK78 0x00000078
-#define NV1_GRAPH 0x00000000
+#define GF100_SUBCHAN_UNK7C 0x0000007c
-#define NV4_GRAPH_NOP 0x00000100
+#define NV40_SUBCHAN_YIELD 0x00000080
-#define NV4_GRAPH_NOTIFY 0x00000104
-#define NV4_GRAPH_NOTIFY_WRITE 0x00000000
-#define NV4_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
+#define NV1_GRAPH 0x00000000
-#define GF100_GRAPH_NOTIFY_ADDRESS_HIGH 0x00000104
+#define NV4_GRAPH_NOP 0x00000100
-#define GF100_GRAPH_NOTIFY_ADDRESS_LOW 0x00000108
+#define NV4_GRAPH_NOTIFY 0x00000104
+#define NV4_GRAPH_NOTIFY_WRITE 0x00000000
+#define NV4_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
-#define GF100_GRAPH_NOTIFY 0x0000010c
-#define GF100_GRAPH_NOTIFY_WRITE 0x00000000
-#define GF100_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
+#define GF100_GRAPH_NOTIFY_ADDRESS_HIGH 0x00000104
-#define G80_GRAPH_SERIALIZE 0x00000110
+#define GF100_GRAPH_NOTIFY_ADDRESS_LOW 0x00000108
-#define GF100_GRAPH_MACRO_CODE_POS 0x00000114
+#define GF100_GRAPH_NOTIFY 0x0000010c
+#define GF100_GRAPH_NOTIFY_WRITE 0x00000000
+#define GF100_GRAPH_NOTIFY_WRITE_AND_AWAKEN 0x00000001
-#define GF100_GRAPH_MACRO_CODE_DATA 0x00000118
+#define G80_GRAPH_SERIALIZE 0x00000110
-#define GF100_GRAPH_MACRO_ENTRY_POS 0x0000011c
+#define GF100_GRAPH_MACRO_CODE_POS 0x00000114
-#define GF100_GRAPH_MACRO_ENTRY_DATA 0x00000120
+#define GF100_GRAPH_MACRO_CODE_DATA 0x00000118
-#define GF100_GRAPH_MACRO_UNK0124 0x00000124
+#define GF100_GRAPH_MACRO_ENTRY_POS 0x0000011c
-#define GT215_GRAPH_UNK0120 0x00000120
+#define GF100_GRAPH_MACRO_ENTRY_DATA 0x00000120
-#define GT215_GRAPH_UNK0124 0x00000124
+#define GF100_GRAPH_MACRO_UNK0124 0x00000124
-#define GF100_GRAPH_COND_MASTER_ADDRESS_HIGH 0x00000130
+#define GT215_GRAPH_UNK0120 0x00000120
-#define GF100_GRAPH_COND_MASTER_ADDRESS_LOW 0x00000134
+#define GT215_GRAPH_UNK0124 0x00000124
-#define GF100_GRAPH_COND_MASTER_MODE 0x00000138
-#define GF100_GRAPH_COND_MASTER_MODE_NEVER 0x00000000
-#define GF100_GRAPH_COND_MASTER_MODE_ALWAYS 0x00000001
-#define GF100_GRAPH_COND_MASTER_MODE_RES_NON_ZERO 0x00000002
-#define GF100_GRAPH_COND_MASTER_MODE_EQUAL 0x00000003
-#define GF100_GRAPH_COND_MASTER_MODE_NOT_EQUAL 0x00000004
+#define GF100_GRAPH_COND_MASTER_ADDRESS_HIGH 0x00000130
-#define GF100_GRAPH_UNK013C 0x0000013c
+#define GF100_GRAPH_COND_MASTER_ADDRESS_LOW 0x00000134
-#define NV40_GRAPH_PM_TRIGGER 0x00000140
+#define GF100_GRAPH_COND_MASTER_MODE 0x00000138
+#define GF100_GRAPH_COND_MASTER_MODE_NEVER 0x00000000
+#define GF100_GRAPH_COND_MASTER_MODE_ALWAYS 0x00000001
+#define GF100_GRAPH_COND_MASTER_MODE_RES_NON_ZERO 0x00000002
+#define GF100_GRAPH_COND_MASTER_MODE_EQUAL 0x00000003
+#define GF100_GRAPH_COND_MASTER_MODE_NOT_EQUAL 0x00000004
-#define GF100_GRAPH_UNK0150 0x00000150
+#define GF100_GRAPH_UNK013C 0x0000013c
-#define GF100_GRAPH_UNK0154 0x00000154
+#define NV40_GRAPH_PM_TRIGGER 0x00000140
-#define GF100_GRAPH_SCRATCH(i0) (0x00003400 + 0x4 * (i0))
-#define GF100_GRAPH_SCRATCH__ESIZE 0x00000004
-#define GF100_GRAPH_SCRATCH__LEN 0x00000080
+#define GF100_GRAPH_UNK0150 0x00000150
-#define GF100_GRAPH_MACRO(i0) (0x00003800 + 0x8 * (i0))
-#define GF100_GRAPH_MACRO__ESIZE 0x00000008
-#define GF100_GRAPH_MACRO__LEN 0x00000080
+#define GF100_GRAPH_UNK0154 0x00000154
+
+#define GF100_GRAPH_SCRATCH(i0) (0x00003400 + 0x4*(i0))
+#define GF100_GRAPH_SCRATCH__ESIZE 0x00000004
+#define GF100_GRAPH_SCRATCH__LEN 0x00000080
+
+#define GF100_GRAPH_MACRO(i0) (0x00003800 + 0x8*(i0))
+#define GF100_GRAPH_MACRO__ESIZE 0x00000008
+#define GF100_GRAPH_MACRO__LEN 0x00000080
+
+#define GF100_GRAPH_MACRO_PARAM(i0) (0x00003804 + 0x8*(i0))
+#define GF100_GRAPH_MACRO_PARAM__ESIZE 0x00000008
+#define GF100_GRAPH_MACRO_PARAM__LEN 0x00000080
-#define GF100_GRAPH_MACRO_PARAM(i0) (0x00003804 + 0x8 * (i0))
-#define GF100_GRAPH_MACRO_PARAM__ESIZE 0x00000008
-#define GF100_GRAPH_MACRO_PARAM__LEN 0x00000080
#endif /* NV_OBJECT_XML */
diff --git a/src/wld/pixman.c b/src/wld/pixman.c
index 4f46119..5f14a7b 100644
--- a/src/wld/pixman.c
+++ b/src/wld/pixman.c
@@ -21,388 +21,430 @@
* SOFTWARE.
*/
-#include "wld/pixman.h"
-#include "wld/wld-private.h"
-
-#define PIXMAN_COLOR(c) \
- { \
- .alpha = ((c >> 24) & 0xff) * 0x101, .red = ((c >> 16) & 0xff) * 0x101, \
- .green = ((c >> 8) & 0xff) * 0x101, .blue = ((c >> 0) & 0xff) * 0x101, \
- }
-
-struct pixman_renderer {
- struct wld_renderer base;
- pixman_image_t *target;
- pixman_glyph_cache_t *glyph_cache;
+#include "pixman.h"
+#include "wld-private.h"
+
+#define PIXMAN_COLOR(c) { \
+ .alpha = ((c >> 24) & 0xff) * 0x101, \
+ .red = ((c >> 16) & 0xff) * 0x101, \
+ .green = ((c >> 8) & 0xff) * 0x101, \
+ .blue = ((c >> 0) & 0xff) * 0x101, \
+}
+
+struct pixman_renderer
+{
+ struct wld_renderer base;
+ pixman_image_t * target;
+ pixman_glyph_cache_t * glyph_cache;
};
-struct pixman_buffer {
- struct buffer base;
- pixman_image_t *image;
+struct pixman_buffer
+{
+ struct buffer base;
+ pixman_image_t * image;
};
-struct pixman_map {
- struct wld_exporter exporter;
- struct wld_destructor destructor;
- pixman_image_t *image;
+struct pixman_map
+{
+ struct wld_exporter exporter;
+ struct wld_destructor destructor;
+ pixman_image_t * image;
};
#include "interface/context.h"
#define RENDERER_IMPLEMENTS_REGION
-#include "interface/buffer.h"
#include "interface/renderer.h"
+#include "interface/buffer.h"
IMPL(pixman_renderer, wld_renderer)
IMPL(pixman_buffer, wld_buffer)
-static struct wld_context context = {.impl = &wld_context_impl};
+static struct wld_context context = { .impl = &wld_context_impl };
EXPORT
-struct wld_context *wld_pixman_context = &context;
+struct wld_context * wld_pixman_context = &context;
-struct wld_renderer *context_create_renderer(struct wld_context *context) {
- struct pixman_renderer *renderer;
+struct wld_renderer * context_create_renderer(struct wld_context * context)
+{
+ struct pixman_renderer * renderer;
- if (!(renderer = malloc(sizeof *renderer)))
- goto error0;
+ if (!(renderer = malloc(sizeof *renderer)))
+ goto error0;
- if (!(renderer->glyph_cache = pixman_glyph_cache_create()))
- goto error1;
+ if (!(renderer->glyph_cache = pixman_glyph_cache_create()))
+ goto error1;
- renderer_initialize(&renderer->base, &wld_renderer_impl);
- renderer->target = NULL;
+ renderer_initialize(&renderer->base, &wld_renderer_impl);
+ renderer->target = NULL;
- return &renderer->base;
+ return &renderer->base;
-error1:
- free(renderer);
-error0:
- return NULL;
+ error1:
+ free(renderer);
+ error0:
+ return NULL;
}
-static struct buffer *new_buffer(pixman_image_t *image) {
- struct pixman_buffer *buffer;
+static struct buffer * new_buffer(pixman_image_t * image)
+{
+ struct pixman_buffer * buffer;
- if (!(buffer = malloc(sizeof *buffer)))
- return NULL;
+ if (!(buffer = malloc(sizeof *buffer)))
+ return NULL;
- buffer_initialize(&buffer->base, &wld_buffer_impl,
- pixman_image_get_width(image),
- pixman_image_get_height(image),
- format_pixman_to_wld(pixman_image_get_format(image)),
- pixman_image_get_stride(image));
- buffer->base.base.map = pixman_image_get_data(image);
- buffer->image = image;
+ buffer_initialize(&buffer->base, &wld_buffer_impl,
+ pixman_image_get_width(image),
+ pixman_image_get_height(image),
+ format_pixman_to_wld(pixman_image_get_format(image)),
+ pixman_image_get_stride(image));
+ buffer->base.base.map = pixman_image_get_data(image);
+ buffer->image = image;
- return &buffer->base;
+ return &buffer->base;
}
-struct buffer *context_create_buffer(struct wld_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t flags) {
- struct buffer *buffer;
- pixman_image_t *image;
+struct buffer * context_create_buffer(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct buffer * buffer;
+ pixman_image_t * image;
- image = pixman_image_create_bits(format_wld_to_pixman(format), width, height,
- NULL, 0);
+ image = pixman_image_create_bits(format_wld_to_pixman(format),
+ width, height, NULL, 0);
- if (!image)
- goto error0;
+ if (!image)
+ goto error0;
- if (!(buffer = new_buffer(image)))
- goto error1;
+ if (!(buffer = new_buffer(image)))
+ goto error1;
- return buffer;
+ return buffer;
-error1:
- pixman_image_unref(image);
-error0:
- return NULL;
+ error1:
+ pixman_image_unref(image);
+ error0:
+ return NULL;
}
-struct buffer *context_import_buffer(struct wld_context *context, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- struct buffer *buffer;
- pixman_image_t *image;
-
- switch (type) {
- case WLD_OBJECT_DATA:
- image = pixman_image_create_bits(format_wld_to_pixman(format), width,
- height, object.ptr, pitch);
- break;
- default:
- image = NULL;
- }
-
- if (!image)
- goto error0;
-
- if (!(buffer = new_buffer(image)))
- goto error1;
-
- return buffer;
-
-error1:
- pixman_image_unref(image);
-error0:
- return NULL;
-}
+struct buffer * context_import_buffer(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ struct buffer * buffer;
+ pixman_image_t * image;
+
+ switch (type)
+ {
+ case WLD_OBJECT_DATA:
+ image = pixman_image_create_bits(format_wld_to_pixman(format),
+ width, height, object.ptr, pitch);
+ break;
+ default: image = NULL;
+ }
+
+ if (!image)
+ goto error0;
-void context_destroy(struct wld_context *context) {}
+ if (!(buffer = new_buffer(image)))
+ goto error1;
+
+ return buffer;
+
+ error1:
+ pixman_image_unref(image);
+ error0:
+ return NULL;
-uint32_t renderer_capabilities(struct wld_renderer *renderer,
- struct buffer *buffer) {
- /* The pixman renderer can read and write to any buffer using it's map
- * implementation. */
- return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
}
-static void destroy_image(pixman_image_t *image, void *data) {
- struct buffer *buffer = data;
+void context_destroy(struct wld_context * context)
+{
+}
- wld_unmap(&buffer->base);
+uint32_t renderer_capabilities(struct wld_renderer * renderer,
+ struct buffer * buffer)
+{
+ /* The pixman renderer can read and write to any buffer using it's map
+ * implementation. */
+ return WLD_CAPABILITY_READ | WLD_CAPABILITY_WRITE;
}
-bool map_export(struct wld_exporter *exporter, struct wld_buffer *buffer,
- uint32_t type, union wld_object *object) {
- struct pixman_map *map = CONTAINER_OF(exporter, struct pixman_map, exporter);
+static void destroy_image(pixman_image_t * image, void * data)
+{
+ struct buffer * buffer = data;
- switch (type) {
- case WLD_PIXMAN_OBJECT_IMAGE:
- object->ptr = pixman_image_ref(map->image);
- return true;
- default:
- return false;
- }
+ wld_unmap(&buffer->base);
}
-void map_destroy(struct wld_destructor *destructor) {
- struct pixman_map *map =
- CONTAINER_OF(destructor, struct pixman_map, destructor);
+bool map_export(struct wld_exporter * exporter, struct wld_buffer * buffer,
+ uint32_t type, union wld_object * object)
+{
+ struct pixman_map * map
+ = CONTAINER_OF(exporter, struct pixman_map, exporter);
+
+ switch (type)
+ {
+ case WLD_PIXMAN_OBJECT_IMAGE:
+ object->ptr = pixman_image_ref(map->image);
+ return true;
+ default:
+ return false;
+ }
+}
- pixman_image_unref(map->image);
- free(map);
+void map_destroy(struct wld_destructor * destructor)
+{
+ struct pixman_map * map
+ = CONTAINER_OF(destructor, struct pixman_map, destructor);
+
+ pixman_image_unref(map->image);
+ free(map);
}
-static pixman_image_t *pixman_image(struct buffer *buffer) {
- if (buffer->base.impl == &wld_buffer_impl)
- return pixman_image_ref(pixman_buffer(&buffer->base)->image);
+static pixman_image_t * pixman_image(struct buffer * buffer)
+{
+ if (buffer->base.impl == &wld_buffer_impl)
+ return pixman_image_ref(pixman_buffer(&buffer->base)->image);
- union wld_object object;
+ union wld_object object;
- if (wld_export(&buffer->base, WLD_PIXMAN_OBJECT_IMAGE, &object))
- return object.ptr;
+ if (wld_export(&buffer->base, WLD_PIXMAN_OBJECT_IMAGE, &object))
+ return object.ptr;
- struct pixman_map *map;
- pixman_image_t *image;
+ struct pixman_map * map;
+ pixman_image_t * image;
- if (!wld_map(&buffer->base))
- goto error0;
+ if (!wld_map(&buffer->base))
+ goto error0;
- image = pixman_image_create_bits(format_wld_to_pixman(buffer->base.format),
- buffer->base.width, buffer->base.height,
- buffer->base.map, buffer->base.pitch);
+ image = pixman_image_create_bits(format_wld_to_pixman(buffer->base.format),
+ buffer->base.width, buffer->base.height,
+ buffer->base.map, buffer->base.pitch);
- if (!image)
- goto error1;
+ if (!image)
+ goto error1;
- if (!(map = malloc(sizeof *map)))
- goto error2;
+ if (!(map = malloc(sizeof *map)))
+ goto error2;
- map->image = image;
- map->exporter.export = &map_export;
- wld_buffer_add_exporter(&buffer->base, &map->exporter);
- map->destructor.destroy = &map_destroy;
- wld_buffer_add_destructor(&buffer->base, &map->destructor);
- pixman_image_set_destroy_function(image, &destroy_image, buffer);
+ map->image = image;
+ map->exporter.export = &map_export;
+ wld_buffer_add_exporter(&buffer->base, &map->exporter);
+ map->destructor.destroy = &map_destroy;
+ wld_buffer_add_destructor(&buffer->base, &map->destructor);
+ pixman_image_set_destroy_function(image, &destroy_image, buffer);
- return pixman_image_ref(image);
+ return pixman_image_ref(image);
-error2:
- pixman_image_unref(image);
-error1:
- wld_unmap(&buffer->base);
-error0:
- return NULL;
+ error2:
+ pixman_image_unref(image);
+ error1:
+ wld_unmap(&buffer->base);
+ error0:
+ return NULL;
}
-bool renderer_set_target(struct wld_renderer *base, struct buffer *buffer) {
- struct pixman_renderer *renderer = pixman_renderer(base);
+bool renderer_set_target(struct wld_renderer * base, struct buffer * buffer)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
- if (renderer->target)
- pixman_image_unref(renderer->target);
+ if (renderer->target)
+ pixman_image_unref(renderer->target);
- if (buffer)
- return (renderer->target = pixman_image(buffer));
+ if (buffer)
+ return (renderer->target = pixman_image(buffer));
- renderer->target = NULL;
- return true;
+ renderer->target = NULL;
+ return true;
}
-void renderer_fill_rectangle(struct wld_renderer *base, uint32_t color,
- int32_t x, int32_t y, uint32_t width,
- uint32_t height) {
- struct pixman_renderer *renderer = pixman_renderer(base);
- pixman_color_t pixman_color = PIXMAN_COLOR(color);
- pixman_box32_t box = {x, y, x + width, y + height};
+void renderer_fill_rectangle(struct wld_renderer * base, uint32_t color,
+ int32_t x, int32_t y,
+ uint32_t width, uint32_t height)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
+ pixman_color_t pixman_color = PIXMAN_COLOR(color);
+ pixman_box32_t box = { x, y, x + width, y + height };
- pixman_image_fill_boxes(PIXMAN_OP_SRC, renderer->target, &pixman_color, 1,
- &box);
+ pixman_image_fill_boxes(PIXMAN_OP_SRC, renderer->target,
+ &pixman_color, 1, &box);
}
-void renderer_fill_region(struct wld_renderer *base, uint32_t color,
- pixman_region32_t *region) {
- struct pixman_renderer *renderer = pixman_renderer(base);
- pixman_color_t pixman_color = PIXMAN_COLOR(color);
- pixman_box32_t *boxes;
- int num_boxes;
-
- boxes = pixman_region32_rectangles(region, &num_boxes);
- pixman_image_fill_boxes(PIXMAN_OP_SRC, renderer->target, &pixman_color,
- num_boxes, boxes);
+void renderer_fill_region(struct wld_renderer * base, uint32_t color,
+ pixman_region32_t * region)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
+ pixman_color_t pixman_color = PIXMAN_COLOR(color);
+ pixman_box32_t * boxes;
+ int num_boxes;
+
+ boxes = pixman_region32_rectangles(region, &num_boxes);
+ pixman_image_fill_boxes(PIXMAN_OP_SRC, renderer->target,
+ &pixman_color, num_boxes, boxes);
}
-void renderer_copy_rectangle(struct wld_renderer *base, struct buffer *buffer,
- int32_t dst_x, int32_t dst_y, int32_t src_x,
- int32_t src_y, uint32_t width, uint32_t height) {
- struct pixman_renderer *renderer = pixman_renderer(base);
- pixman_image_t *src = pixman_image(buffer), *dst = renderer->target;
+void renderer_copy_rectangle(struct wld_renderer * base, struct buffer * buffer,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
+ pixman_image_t * src = pixman_image(buffer), * dst = renderer->target;
- if (!src)
- return;
+ if (!src) return;
- pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst, src_x, src_y, 0, 0,
- dst_x, dst_y, width, height);
+ pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst,
+ src_x, src_y, 0, 0, dst_x, dst_y, width, height);
}
-void renderer_copy_region(struct wld_renderer *base, struct buffer *buffer,
+void renderer_copy_region(struct wld_renderer * base, struct buffer * buffer,
int32_t dst_x, int32_t dst_y,
- pixman_region32_t *region) {
- struct pixman_renderer *renderer = pixman_renderer(base);
- pixman_image_t *src = pixman_image(buffer), *dst = renderer->target;
-
- if (!src)
- return;
-
- pixman_image_set_clip_region32(src, region);
- pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst, region->extents.x1,
- region->extents.y1, 0, 0, region->extents.x1 + dst_x,
- region->extents.y1 + dst_y,
- region->extents.x2 - region->extents.x1,
- region->extents.y2 - region->extents.y1);
- pixman_image_set_clip_region32(src, NULL);
+ pixman_region32_t * region)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
+ pixman_image_t * src = pixman_image(buffer), * dst = renderer->target;
+
+ if (!src) return;
+
+ pixman_image_set_clip_region32(src, region);
+ pixman_image_composite32(PIXMAN_OP_SRC, src, NULL, dst,
+ region->extents.x1, region->extents.y1, 0, 0,
+ region->extents.x1 + dst_x,
+ region->extents.y1 + dst_y,
+ region->extents.x2 - region->extents.x1,
+ region->extents.y2 - region->extents.y1);
+ pixman_image_set_clip_region32(src, NULL);
}
-static inline uint8_t reverse(uint8_t byte) {
- byte = ((byte << 1) & 0xaa) | ((byte >> 1) & 0x55);
- byte = ((byte << 2) & 0xcc) | ((byte >> 2) & 0x33);
- byte = ((byte << 4) & 0xf0) | ((byte >> 4) & 0x0f);
+static inline uint8_t reverse(uint8_t byte)
+{
+ byte = ((byte << 1) & 0xaa) | ((byte >> 1) & 0x55);
+ byte = ((byte << 2) & 0xcc) | ((byte >> 2) & 0x33);
+ byte = ((byte << 4) & 0xf0) | ((byte >> 4) & 0x0f);
- return byte;
+ return byte;
}
-void renderer_draw_text(struct wld_renderer *base, struct font *font,
- uint32_t color, int32_t x, int32_t y, const char *text,
- uint32_t length, struct wld_extents *extents) {
- struct pixman_renderer *renderer = pixman_renderer(base);
- int ret;
- uint32_t c;
- struct glyph *glyph;
- FT_UInt glyph_index;
- pixman_glyph_t glyphs[length == -1 ? (length = strlen(text)) : length];
- uint32_t index = 0, origin_x = 0;
- pixman_color_t pixman_color = PIXMAN_COLOR(color);
- pixman_image_t *solid;
-
- solid = pixman_image_create_solid_fill(&pixman_color);
-
- while ((ret = FcUtf8ToUcs4((FcChar8 *)text, &c, length)) > 0 && c != '\0') {
- text += ret;
- length -= ret;
- glyph_index = FT_Get_Char_Index(font->face, c);
-
- if (!font_ensure_glyph(font, glyph_index))
- continue;
-
- glyph = font->glyphs[glyph_index];
-
- glyphs[index].x = origin_x;
- glyphs[index].y = 0;
- glyphs[index].glyph =
- pixman_glyph_cache_lookup(renderer->glyph_cache, font, glyph);
-
- /* If we don't have the glyph in our cache, do some conversions to make
- * pixman happy, and then insert it. */
- if (!glyphs[index].glyph) {
- uint8_t *src, *dst;
- uint32_t row, byte_index, bytes_per_row, pitch;
- pixman_image_t *image;
- FT_Bitmap *bitmap;
-
- bitmap = &glyph->bitmap;
- image = pixman_image_create_bits(PIXMAN_a1, bitmap->width, bitmap->rows,
- NULL, bitmap->pitch);
-
- if (!image)
- goto advance;
-
- pitch = pixman_image_get_stride(image);
- bytes_per_row = (bitmap->width + 7) / 8;
- src = bitmap->buffer;
- dst = (uint8_t *)pixman_image_get_data(image);
-
- for (row = 0; row < bitmap->rows; ++row) {
- /* Pixman's A1 format expects the bits in the opposite order
- * that Freetype gives us. Sigh... */
- for (byte_index = 0; byte_index < bytes_per_row; ++byte_index)
- dst[byte_index] = reverse(src[byte_index]);
-
- dst += pitch;
- src += bitmap->pitch;
- }
-
- /* Insert the glyph into the cache. */
- pixman_glyph_cache_freeze(renderer->glyph_cache);
- glyphs[index].glyph = pixman_glyph_cache_insert(
- renderer->glyph_cache, font, glyph, -glyph->x, -glyph->y, image);
- pixman_glyph_cache_thaw(renderer->glyph_cache);
-
- /* The glyph cache copies the contents of the glyph bitmap. */
- pixman_image_unref(image);
+void renderer_draw_text(struct wld_renderer * base,
+ struct font * font, uint32_t color,
+ int32_t x, int32_t y, const char * text,
+ uint32_t length, struct wld_extents * extents)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
+ int ret;
+ uint32_t c;
+ struct glyph * glyph;
+ FT_UInt glyph_index;
+ pixman_glyph_t glyphs[length == -1 ? (length = strlen(text)) : length];
+ uint32_t index = 0, origin_x = 0;
+ pixman_color_t pixman_color = PIXMAN_COLOR(color);
+ pixman_image_t * solid;
+
+ solid = pixman_image_create_solid_fill(&pixman_color);
+
+ while ((ret = FcUtf8ToUcs4((FcChar8 *) text, &c, length)) > 0 && c != '\0')
+ {
+ text += ret;
+ length -= ret;
+ glyph_index = FT_Get_Char_Index(font->face, c);
+
+ if (!font_ensure_glyph(font, glyph_index))
+ continue;
+
+ glyph = font->glyphs[glyph_index];
+
+ glyphs[index].x = origin_x;
+ glyphs[index].y = 0;
+ glyphs[index].glyph = pixman_glyph_cache_lookup(renderer->glyph_cache,
+ font, glyph);
+
+ /* If we don't have the glyph in our cache, do some conversions to make
+ * pixman happy, and then insert it. */
+ if (!glyphs[index].glyph)
+ {
+ uint8_t * src, * dst;
+ uint32_t row, byte_index, bytes_per_row, pitch;
+ pixman_image_t * image;
+ FT_Bitmap * bitmap;
+
+ bitmap = &glyph->bitmap;
+ image = pixman_image_create_bits
+ (PIXMAN_a1, bitmap->width, bitmap->rows, NULL, bitmap->pitch);
+
+ if (!image)
+ goto advance;
+
+ pitch = pixman_image_get_stride(image);
+ bytes_per_row = (bitmap->width + 7) / 8;
+ src = bitmap->buffer;
+ dst = (uint8_t *) pixman_image_get_data(image);
+
+ for (row = 0; row < bitmap->rows; ++row)
+ {
+ /* Pixman's A1 format expects the bits in the opposite order
+ * that Freetype gives us. Sigh... */
+ for (byte_index = 0; byte_index < bytes_per_row; ++byte_index)
+ dst[byte_index] = reverse(src[byte_index]);
+
+ dst += pitch;
+ src += bitmap->pitch;
+ }
+
+ /* Insert the glyph into the cache. */
+ pixman_glyph_cache_freeze(renderer->glyph_cache);
+ glyphs[index].glyph = pixman_glyph_cache_insert
+ (renderer->glyph_cache, font, glyph,
+ -glyph->x, -glyph->y, image);
+ pixman_glyph_cache_thaw(renderer->glyph_cache);
+
+ /* The glyph cache copies the contents of the glyph bitmap. */
+ pixman_image_unref(image);
+ }
+
+ ++index;
+
+ advance:
+ origin_x += glyph->advance;
}
- ++index;
-
- advance:
- origin_x += glyph->advance;
- }
+ pixman_composite_glyphs_no_mask(PIXMAN_OP_OVER, solid, renderer->target,
+ 0, 0, x, y, renderer->glyph_cache,
+ index, glyphs);
- pixman_composite_glyphs_no_mask(PIXMAN_OP_OVER, solid, renderer->target, 0, 0,
- x, y, renderer->glyph_cache, index, glyphs);
+ pixman_image_unref(solid);
- pixman_image_unref(solid);
-
- if (extents)
- extents->advance = origin_x;
+ if (extents)
+ extents->advance = origin_x;
}
-void renderer_flush(struct wld_renderer *renderer) {}
+void renderer_flush(struct wld_renderer * renderer)
+{
+}
-void renderer_destroy(struct wld_renderer *base) {
- struct pixman_renderer *renderer = pixman_renderer(base);
+void renderer_destroy(struct wld_renderer * base)
+{
+ struct pixman_renderer * renderer = pixman_renderer(base);
- pixman_glyph_cache_destroy(renderer->glyph_cache);
- free(renderer);
+ pixman_glyph_cache_destroy(renderer->glyph_cache);
+ free(renderer);
}
-bool buffer_map(struct buffer *buffer) { return true; }
+bool buffer_map(struct buffer * buffer)
+{
+ return true;
+}
-bool buffer_unmap(struct buffer *buffer) { return true; }
+bool buffer_unmap(struct buffer * buffer)
+{
+ return true;
+}
-void buffer_destroy(struct buffer *base) {
- struct pixman_buffer *buffer = pixman_buffer(&base->base);
+void buffer_destroy(struct buffer * base)
+{
+ struct pixman_buffer * buffer = pixman_buffer(&base->base);
- pixman_image_unref(buffer->image);
- free(buffer);
+ pixman_image_unref(buffer->image);
+ free(buffer);
}
+
diff --git a/src/wld/pixman.h b/src/wld/pixman.h
new file mode 100644
index 0000000..c864385
--- /dev/null
+++ b/src/wld/pixman.h
@@ -0,0 +1,44 @@
+/* wld: pixman.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_PIXMAN_H
+#define WLD_PIXMAN_H
+
+#include <stdint.h>
+
+#define WLD_PIXMAN_ID (0x01 << 24)
+
+enum wld_pixman_object_type
+{
+ WLD_PIXMAN_OBJECT_IMAGE = WLD_PIXMAN_ID
+};
+
+extern struct wld_context * wld_pixman_context;
+
+static inline struct wld_context * wld_pixman_create_context()
+{
+ return wld_pixman_context;
+}
+
+#endif
+
diff --git a/src/wld/renderer.c b/src/wld/renderer.c
index be4a03c..a038095 100644
--- a/src/wld/renderer.c
+++ b/src/wld/renderer.c
@@ -21,116 +21,137 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
-
-void default_fill_region(struct wld_renderer *renderer, uint32_t color,
- pixman_region32_t *region) {
- pixman_box32_t *box;
- int num_boxes;
-
- box = pixman_region32_rectangles(region, &num_boxes);
-
- while (num_boxes--) {
- renderer->impl->fill_rectangle(renderer, color, box->x1, box->y1,
- box->x2 - box->x1, box->y2 - box->y1);
- ++box;
- }
+#include "wld-private.h"
+
+void default_fill_region(struct wld_renderer * renderer, uint32_t color,
+ pixman_region32_t * region)
+{
+ pixman_box32_t * box;
+ int num_boxes;
+
+ box = pixman_region32_rectangles(region, &num_boxes);
+
+ while (num_boxes--)
+ {
+ renderer->impl->fill_rectangle(renderer, color, box->x1, box->y1,
+ box->x2 - box->x1, box->y2 - box->y1);
+ ++box;
+ }
}
-void default_copy_region(struct wld_renderer *renderer, struct buffer *buffer,
+void default_copy_region(struct wld_renderer * renderer, struct buffer * buffer,
int32_t dst_x, int32_t dst_y,
- pixman_region32_t *region) {
- pixman_box32_t *box;
- int num_boxes;
-
- box = pixman_region32_rectangles(region, &num_boxes);
-
- while (num_boxes--) {
- renderer->impl->copy_rectangle(renderer, buffer, dst_x + box->x1,
- dst_y + box->y1, box->x1, box->y1,
- box->x2 - box->x1, box->y2 - box->y1);
- ++box;
- }
+ pixman_region32_t * region)
+{
+ pixman_box32_t * box;
+ int num_boxes;
+
+ box = pixman_region32_rectangles(region, &num_boxes);
+
+ while (num_boxes--)
+ {
+ renderer->impl->copy_rectangle(renderer, buffer,
+ dst_x + box->x1, dst_y + box->y1,
+ box->x1, box->y1,
+ box->x2 - box->x1, box->y2 - box->y1);
+ ++box;
+ }
}
-void renderer_initialize(struct wld_renderer *renderer,
- const struct wld_renderer_impl *impl) {
- *((const struct wld_renderer_impl **)&renderer->impl) = impl;
- renderer->target = NULL;
+void renderer_initialize(struct wld_renderer * renderer,
+ const struct wld_renderer_impl * impl)
+{
+ *((const struct wld_renderer_impl **) &renderer->impl) = impl;
+ renderer->target = NULL;
}
EXPORT
-void wld_destroy_renderer(struct wld_renderer *renderer) {
- renderer->impl->destroy(renderer);
+void wld_destroy_renderer(struct wld_renderer * renderer)
+{
+ renderer->impl->destroy(renderer);
}
EXPORT
-uint32_t wld_capabilities(struct wld_renderer *renderer,
- struct wld_buffer *buffer) {
- return renderer->impl->capabilities(renderer, (struct buffer *)buffer);
+uint32_t wld_capabilities(struct wld_renderer * renderer,
+ struct wld_buffer * buffer)
+{
+ return renderer->impl->capabilities(renderer, (struct buffer *) buffer);
}
EXPORT
-bool wld_set_target_buffer(struct wld_renderer *renderer,
- struct wld_buffer *buffer) {
- if (!renderer->impl->set_target(renderer, (struct buffer *)buffer))
- return false;
+bool wld_set_target_buffer(struct wld_renderer * renderer,
+ struct wld_buffer * buffer)
+{
+ if (!renderer->impl->set_target(renderer, (struct buffer *) buffer))
+ return false;
- renderer->target = buffer;
+ renderer->target = buffer;
- return true;
+ return true;
}
EXPORT
-bool wld_set_target_surface(struct wld_renderer *renderer,
- struct wld_surface *surface) {
- struct buffer *back_buffer;
+bool wld_set_target_surface(struct wld_renderer * renderer,
+ struct wld_surface * surface)
+{
+ struct buffer * back_buffer;
- if (!(back_buffer = surface->impl->back(surface)))
- return false;
+ if (!(back_buffer = surface->impl->back(surface)))
+ return false;
- return renderer->impl->set_target(renderer, back_buffer);
+ return renderer->impl->set_target(renderer, back_buffer);
}
EXPORT
-void wld_fill_rectangle(struct wld_renderer *renderer, uint32_t color,
- int32_t x, int32_t y, uint32_t width, uint32_t height) {
- renderer->impl->fill_rectangle(renderer, color, x, y, width, height);
+void wld_fill_rectangle(struct wld_renderer * renderer, uint32_t color,
+ int32_t x, int32_t y, uint32_t width, uint32_t height)
+{
+ renderer->impl->fill_rectangle(renderer, color, x, y, width, height);
}
EXPORT
-void wld_fill_region(struct wld_renderer *renderer, uint32_t color,
- pixman_region32_t *region) {
- renderer->impl->fill_region(renderer, color, region);
+void wld_fill_region(struct wld_renderer * renderer, uint32_t color,
+ pixman_region32_t * region)
+{
+ renderer->impl->fill_region(renderer, color, region);
}
EXPORT
-void wld_copy_rectangle(struct wld_renderer *renderer,
- struct wld_buffer *buffer, int32_t dst_x, int32_t dst_y,
- int32_t src_x, int32_t src_y, uint32_t width,
- uint32_t height) {
- renderer->impl->copy_rectangle(renderer, (struct buffer *)buffer, dst_x,
- dst_y, src_x, src_y, width, height);
+void wld_copy_rectangle(struct wld_renderer * renderer,
+ struct wld_buffer * buffer,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height)
+{
+ renderer->impl->copy_rectangle(renderer, (struct buffer *) buffer,
+ dst_x, dst_y, src_x, src_y, width, height);
}
EXPORT
-void wld_copy_region(struct wld_renderer *renderer, struct wld_buffer *buffer,
- int32_t dst_x, int32_t dst_y, pixman_region32_t *region) {
- renderer->impl->copy_region(renderer, (struct buffer *)buffer, dst_x, dst_y,
- region);
+void wld_copy_region(struct wld_renderer * renderer,
+ struct wld_buffer * buffer,
+ int32_t dst_x, int32_t dst_y, pixman_region32_t * region)
+{
+ renderer->impl->copy_region(renderer, (struct buffer *) buffer,
+ dst_x, dst_y, region);
}
EXPORT
-void wld_draw_text(struct wld_renderer *renderer, struct wld_font *font_base,
- uint32_t color, int32_t x, int32_t y, const char *text,
- uint32_t length, struct wld_extents *extents) {
- struct font *font = (void *)font_base;
-
- renderer->impl->draw_text(renderer, font, color, x, y, text, length, extents);
+void wld_draw_text(struct wld_renderer * renderer,
+ struct wld_font * font_base, uint32_t color,
+ int32_t x, int32_t y, const char * text, uint32_t length,
+ struct wld_extents * extents)
+{
+ struct font * font = (void *) font_base;
+
+ renderer->impl->draw_text(renderer, font, color, x, y, text, length,
+ extents);
}
EXPORT
-void wld_flush(struct wld_renderer *renderer) {
- renderer->impl->flush(renderer);
- renderer->impl->set_target(renderer, NULL);
+void wld_flush(struct wld_renderer * renderer)
+{
+ renderer->impl->flush(renderer);
+ renderer->impl->set_target(renderer, NULL);
}
+
diff --git a/src/wld/surface.c b/src/wld/surface.c
index 7e1e396..3f936bd 100644
--- a/src/wld/surface.c
+++ b/src/wld/surface.c
@@ -21,42 +21,50 @@
* SOFTWARE.
*/
-#include "wld/wld-private.h"
+#include "wld-private.h"
-struct wld_surface *default_create_surface(struct wld_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t flags) {
- return buffered_surface_create(context, width, height, format, flags, NULL);
+struct wld_surface * default_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ return buffered_surface_create(context, width, height, format, flags, NULL);
}
-void surface_initialize(struct wld_surface *surface,
- const struct wld_surface_impl *impl) {
- *((const struct wld_surface_impl **)&surface->impl) = impl;
+void surface_initialize(struct wld_surface * surface,
+ const struct wld_surface_impl * impl)
+{
+ *((const struct wld_surface_impl **) &surface->impl) = impl;
}
EXPORT
-pixman_region32_t *wld_surface_damage(struct wld_surface *surface,
- pixman_region32_t *new_damage) {
- return surface->impl->damage(surface, new_damage);
+pixman_region32_t * wld_surface_damage(struct wld_surface * surface,
+ pixman_region32_t * new_damage)
+{
+ return surface->impl->damage(surface, new_damage);
}
EXPORT
-struct wld_buffer *wld_surface_take(struct wld_surface *surface) {
- return &surface->impl->take(surface)->base;
+struct wld_buffer * wld_surface_take(struct wld_surface * surface)
+{
+ return &surface->impl->take(surface)->base;
}
EXPORT
-void wld_surface_release(struct wld_surface *surface,
- struct wld_buffer *buffer) {
- surface->impl->release(surface, (struct buffer *)buffer);
+void wld_surface_release(struct wld_surface * surface,
+ struct wld_buffer * buffer)
+{
+ surface->impl->release(surface, (struct buffer *) buffer);
}
EXPORT
-bool wld_swap(struct wld_surface *surface) {
- return surface->impl->swap(surface);
+bool wld_swap(struct wld_surface * surface)
+{
+ return surface->impl->swap(surface);
}
EXPORT
-void wld_destroy_surface(struct wld_surface *surface) {
- surface->impl->destroy(surface);
+void wld_destroy_surface(struct wld_surface * surface)
+{
+ surface->impl->destroy(surface);
}
+
diff --git a/src/wld/wayland-drm.c b/src/wld/wayland-drm.c
index 51dbcb7..024e14c 100644
--- a/src/wld/wayland-drm.c
+++ b/src/wld/wayland-drm.c
@@ -21,28 +21,29 @@
* SOFTWARE.
*/
-#include "wayland-drm-client-protocol.h"
-#include "wld/drm-private.h"
-#include "wld/drm.h"
-#include "wld/wayland-private.h"
-#include "wld/wayland.h"
-#include "wld/wld-private.h"
+#include "wayland.h"
+#include "drm.h"
+#include "protocol/wayland-drm-client-protocol.h"
+#include "wayland-private.h"
+#include "wld-private.h"
+#include "drm-private.h"
-#include <fcntl.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
+#include <fcntl.h>
#include <xf86drm.h>
-struct drm_context {
- struct wayland_context base;
- struct wld_context *driver_context;
- struct wl_drm *wl;
- struct wl_registry *registry;
- struct wl_array formats;
- uint32_t capabilities;
- int fd;
- bool authenticated;
+struct drm_context
+{
+ struct wayland_context base;
+ struct wld_context * driver_context;
+ struct wl_drm * wl;
+ struct wl_registry * registry;
+ struct wl_array formats;
+ uint32_t capabilities;
+ int fd;
+ bool authenticated;
};
#define WAYLAND_IMPL_NAME drm
@@ -50,221 +51,246 @@ struct drm_context {
#include "interface/wayland.h"
IMPL(drm_context, wld_context)
-static void registry_global(void *data, struct wl_registry *registry,
- uint32_t name, const char *interface,
+static void registry_global(void * data, struct wl_registry * registry,
+ uint32_t name, const char * interface,
uint32_t version);
-static void registry_global_remove(void *data, struct wl_registry *registry,
+static void registry_global_remove(void * data, struct wl_registry * registry,
uint32_t name);
-static void drm_device(void *data, struct wl_drm *wl, const char *name);
-static void drm_format(void *data, struct wl_drm *wl, uint32_t format);
-static void drm_authenticated(void *data, struct wl_drm *wl);
-static void drm_capabilities(void *data, struct wl_drm *wl,
+static void drm_device(void * data, struct wl_drm * wl, const char * name);
+static void drm_format(void * data, struct wl_drm * wl, uint32_t format);
+static void drm_authenticated(void * data, struct wl_drm * wl);
+static void drm_capabilities(void * data, struct wl_drm * wl,
uint32_t capabilities);
const static struct wl_registry_listener registry_listener = {
- .global = &registry_global, .global_remove = &registry_global_remove};
+ .global = &registry_global,
+ .global_remove = &registry_global_remove
+};
const static struct wl_drm_listener drm_listener = {
.device = &drm_device,
.format = &drm_format,
.authenticated = &drm_authenticated,
- .capabilities = &drm_capabilities};
-
-struct wayland_context *wayland_create_context(struct wl_display *display,
- struct wl_event_queue *queue) {
- struct drm_context *context;
-
- if (!(context = malloc(sizeof *context)))
- goto error0;
-
- context_initialize(&context->base.base, &wld_context_impl);
- context->wl = NULL;
- context->fd = -1;
- context->capabilities = 0;
- wl_array_init(&context->formats);
-
- if (!(context->registry = wl_display_get_registry(display)))
- goto error1;
-
- wl_registry_add_listener(context->registry, &registry_listener, context);
- wl_proxy_set_queue((struct wl_proxy *)context->registry, queue);
-
- /* Wait for wl_drm global. */
- wl_display_roundtrip_queue(display, queue);
-
- if (!context->wl) {
- DEBUG("No wl_drm global\n");
- goto error2;
- }
-
- wl_drm_add_listener(context->wl, &drm_listener, context);
-
- /* Wait for DRM capabilities and device. */
- wl_display_roundtrip_queue(display, queue);
-
- if (!(context->capabilities & WL_DRM_CAPABILITY_PRIME)) {
- DEBUG("No PRIME support\n");
- goto error3;
- }
-
- if (context->fd == -1) {
- DEBUG("No DRM device\n");
- goto error3;
- }
-
- /* Wait for DRM authentication. */
- wl_display_roundtrip_queue(display, queue);
-
- if (!context->authenticated) {
- DEBUG("DRM authentication failed\n");
- goto error4;
- }
-
- if (!(context->driver_context = wld_drm_create_context(context->fd))) {
- DEBUG("Couldn't initialize context for DRM device\n");
- goto error4;
- }
-
- return &context->base;
-
-error4:
- close(context->fd);
-error3:
- wl_drm_destroy(context->wl);
-error2:
- wl_registry_destroy(context->registry);
-error1:
- wl_array_release(&context->formats);
- free(context);
-error0:
- return NULL;
+ .capabilities = &drm_capabilities
+};
+
+struct wayland_context * wayland_create_context(struct wl_display * display,
+ struct wl_event_queue * queue)
+{
+ struct drm_context * context;
+
+ if (!(context = malloc(sizeof *context)))
+ goto error0;
+
+ context_initialize(&context->base.base, &wld_context_impl);
+ context->wl = NULL;
+ context->fd = -1;
+ context->capabilities = 0;
+ wl_array_init(&context->formats);
+
+ if (!(context->registry = wl_display_get_registry(display)))
+ goto error1;
+
+ wl_registry_add_listener(context->registry, &registry_listener, context);
+ wl_proxy_set_queue((struct wl_proxy *) context->registry, queue);
+
+ /* Wait for wl_drm global. */
+ wl_display_roundtrip_queue(display, queue);
+
+ if (!context->wl)
+ {
+ DEBUG("No wl_drm global\n");
+ goto error2;
+ }
+
+ wl_drm_add_listener(context->wl, &drm_listener, context);
+
+ /* Wait for DRM capabilities and device. */
+ wl_display_roundtrip_queue(display, queue);
+
+ if (!(context->capabilities & WL_DRM_CAPABILITY_PRIME))
+ {
+ DEBUG("No PRIME support\n");
+ goto error3;
+ }
+
+ if (context->fd == -1)
+ {
+ DEBUG("No DRM device\n");
+ goto error3;
+ }
+
+ /* Wait for DRM authentication. */
+ wl_display_roundtrip_queue(display, queue);
+
+ if (!context->authenticated)
+ {
+ DEBUG("DRM authentication failed\n");
+ goto error4;
+ }
+
+ if (!(context->driver_context = wld_drm_create_context(context->fd)))
+ {
+ DEBUG("Couldn't initialize context for DRM device\n");
+ goto error4;
+ }
+
+ return &context->base;
+
+ error4:
+ close(context->fd);
+ error3:
+ wl_drm_destroy(context->wl);
+ error2:
+ wl_registry_destroy(context->registry);
+ error1:
+ wl_array_release(&context->formats);
+ free(context);
+ error0:
+ return NULL;
}
-bool wayland_has_format(struct wld_context *base, uint32_t format) {
- struct drm_context *context = drm_context(base);
- uint32_t *supported_format;
+bool wayland_has_format(struct wld_context * base, uint32_t format)
+{
+ struct drm_context * context = drm_context(base);
+ uint32_t * supported_format;
- wl_array_for_each(supported_format, &context->formats) {
- if (*supported_format == format)
- return true;
- }
+ wl_array_for_each(supported_format, &context->formats)
+ {
+ if (*supported_format == format)
+ return true;
+ }
- return false;
+ return false;
}
EXPORT
-int wld_wayland_drm_get_fd(struct wld_context *base) {
- struct drm_context *context = drm_context(base);
+int wld_wayland_drm_get_fd(struct wld_context * base)
+{
+ struct drm_context * context = drm_context(base);
- return context->authenticated ? context->fd : -1;
+ return context->authenticated ? context->fd : -1;
}
-struct wld_renderer *context_create_renderer(struct wld_context *base) {
- struct drm_context *context = drm_context(base);
+struct wld_renderer * context_create_renderer(struct wld_context * base)
+{
+ struct drm_context * context = drm_context(base);
- return wld_create_renderer(context->driver_context);
+ return wld_create_renderer(context->driver_context);
}
-struct buffer *context_create_buffer(struct wld_context *base, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t flags) {
- struct drm_context *context = drm_context(base);
- struct buffer *buffer;
- union wld_object object;
- struct wl_buffer *wl;
+struct buffer * context_create_buffer(struct wld_context * base,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct drm_context * context = drm_context(base);
+ struct buffer * buffer;
+ union wld_object object;
+ struct wl_buffer * wl;
- if (!wayland_has_format(base, format))
- goto error0;
+ if (!wayland_has_format(base, format))
+ goto error0;
- buffer = context->driver_context->impl->create_buffer(
- context->driver_context, width, height, format, flags);
+ buffer = context->driver_context->impl->create_buffer
+ (context->driver_context, width, height, format, flags);
- if (!buffer)
- goto error0;
+ if (!buffer)
+ goto error0;
- if (!wld_export(&buffer->base, WLD_DRM_OBJECT_PRIME_FD, &object))
- goto error1;
+ if (!wld_export(&buffer->base, WLD_DRM_OBJECT_PRIME_FD, &object))
+ goto error1;
- wl = wl_drm_create_prime_buffer(context->wl, object.i, width, height, format,
- 0, buffer->base.pitch, 0, 0, 0, 0);
- close(object.i);
+ wl = wl_drm_create_prime_buffer(context->wl, object.i, width, height,
+ format, 0, buffer->base.pitch, 0, 0, 0, 0);
+ close(object.i);
- if (!wl)
- goto error1;
+ if (!wl)
+ goto error1;
- if (!wayland_buffer_add_exporter(buffer, wl))
- goto error2;
+ if (!wayland_buffer_add_exporter(buffer, wl))
+ goto error2;
- return buffer;
+ return buffer;
-error2:
- wl_buffer_destroy(wl);
-error1:
- wld_buffer_unreference(&buffer->base);
-error0:
- return NULL;
+ error2:
+ wl_buffer_destroy(wl);
+ error1:
+ wld_buffer_unreference(&buffer->base);
+ error0:
+ return NULL;
}
-struct buffer *context_import_buffer(struct wld_context *context, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- return NULL;
+struct buffer * context_import_buffer(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ return NULL;
}
-void context_destroy(struct wld_context *base) {
- struct drm_context *context = drm_context(base);
-
- wld_destroy_context(context->driver_context);
- close(context->fd);
- wl_drm_destroy(context->wl);
- wl_registry_destroy(context->registry);
- wl_array_release(&context->formats);
- wl_event_queue_destroy(context->base.queue);
- free(context);
+void context_destroy(struct wld_context * base)
+{
+ struct drm_context * context = drm_context(base);
+
+ wld_destroy_context(context->driver_context);
+ close(context->fd);
+ wl_drm_destroy(context->wl);
+ wl_registry_destroy(context->registry);
+ wl_array_release(&context->formats);
+ wl_event_queue_destroy(context->base.queue);
+ free(context);
}
-void registry_global(void *data, struct wl_registry *registry, uint32_t name,
- const char *interface, uint32_t version) {
- struct drm_context *context = data;
+void registry_global(void * data, struct wl_registry * registry, uint32_t name,
+ const char * interface, uint32_t version)
+{
+ struct drm_context * context = data;
- if (strcmp(interface, "wl_drm") == 0 && version >= 2)
- context->wl = wl_registry_bind(registry, name, &wl_drm_interface, 2);
+ if (strcmp(interface, "wl_drm") == 0 && version >= 2)
+ context->wl = wl_registry_bind(registry, name, &wl_drm_interface, 2);
}
-void registry_global_remove(void *data, struct wl_registry *registry,
- uint32_t name) {}
+void registry_global_remove(void * data, struct wl_registry * registry,
+ uint32_t name)
+{
+}
-void drm_device(void *data, struct wl_drm *wl, const char *name) {
- struct drm_context *context = data;
- drm_magic_t magic;
+void drm_device(void * data, struct wl_drm * wl, const char * name)
+{
+ struct drm_context * context = data;
+ drm_magic_t magic;
- context->fd = open(name, O_RDWR);
+ context->fd = open(name, O_RDWR);
- if (context->fd == -1) {
- DEBUG("Couldn't open DRM device '%s'\n", name);
- return;
- }
+ if (context->fd == -1)
+ {
+ DEBUG("Couldn't open DRM device '%s'\n", name);
+ return;
+ }
- drmGetMagic(context->fd, &magic);
- wl_drm_authenticate(wl, magic);
+ drmGetMagic(context->fd, &magic);
+ wl_drm_authenticate(wl, magic);
}
-void drm_format(void *data, struct wl_drm *wl, uint32_t format) {
- struct drm_context *context = data;
+void drm_format(void * data, struct wl_drm * wl, uint32_t format)
+{
+ struct drm_context * context = data;
- *((uint32_t *)wl_array_add(&context->formats, sizeof format)) = format;
+ *((uint32_t *) wl_array_add(&context->formats, sizeof format)) = format;
}
-void drm_authenticated(void *data, struct wl_drm *wl) {
- struct drm_context *context = data;
+void drm_authenticated(void * data, struct wl_drm * wl)
+{
+ struct drm_context * context = data;
- context->authenticated = true;
+ context->authenticated = true;
}
-void drm_capabilities(void *data, struct wl_drm *wl, uint32_t capabilities) {
- struct drm_context *context = data;
+void drm_capabilities(void * data, struct wl_drm * wl, uint32_t capabilities)
+{
+ struct drm_context * context = data;
- context->capabilities = capabilities;
+ context->capabilities = capabilities;
}
+
diff --git a/src/wld/wayland-private.h b/src/wld/wayland-private.h
new file mode 100644
index 0000000..f52e3ae
--- /dev/null
+++ b/src/wld/wayland-private.h
@@ -0,0 +1,60 @@
+/* wld: wayland-private.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_WAYLAND_PRIVATE_H
+#define WLD_WAYLAND_PRIVATE_H
+
+#include "wld.h"
+
+struct buffer;
+struct wl_display;
+struct wl_event_queue;
+struct wl_buffer;
+
+struct wayland_context
+{
+ struct wld_context base;
+ const struct wayland_impl * impl;
+ struct wl_display * display;
+ struct wl_event_queue * queue;
+};
+
+struct wayland_impl
+{
+ struct wayland_context * (* create_context)(struct wl_display * display,
+ struct wl_event_queue * queue);
+ bool (* has_format)(struct wld_context * context, uint32_t format);
+};
+
+#if WITH_WAYLAND_DRM
+extern const struct wayland_impl drm_wayland_impl;
+#endif
+
+#if WITH_WAYLAND_SHM
+extern const struct wayland_impl shm_wayland_impl;
+#endif
+
+bool wayland_buffer_add_exporter(struct buffer * buffer, struct wl_buffer * wl);
+
+#endif
+
diff --git a/src/wld/wayland-shm.c b/src/wld/wayland-shm.c
index 4c58133..520eb2c 100644
--- a/src/wld/wayland-shm.c
+++ b/src/wld/wayland-shm.c
@@ -23,10 +23,10 @@
#define _GNU_SOURCE /* Required for mkostemp */
-#include "wld/pixman.h"
-#include "wld/wayland-private.h"
-#include "wld/wayland.h"
-#include "wld/wld-private.h"
+#include "wayland.h"
+#include "wayland-private.h"
+#include "wld-private.h"
+#include "pixman.h"
#include <fcntl.h>
#include <stdlib.h>
@@ -35,236 +35,260 @@
#include <unistd.h>
#include <wayland-client.h>
-struct shm_context {
- struct wayland_context base;
- struct wl_registry *registry;
- struct wl_shm *wl;
- struct wl_array formats;
+struct shm_context
+{
+ struct wayland_context base;
+ struct wl_registry * registry;
+ struct wl_shm * wl;
+ struct wl_array formats;
};
-struct shm_buffer {
- struct buffer base;
- int fd;
+struct shm_buffer
+{
+ struct buffer base;
+ int fd;
};
#define WAYLAND_IMPL_NAME shm
-#include "interface/buffer.h"
#include "interface/context.h"
+#include "interface/buffer.h"
#include "interface/wayland.h"
IMPL(shm_context, wld_context)
IMPL(shm_buffer, wld_buffer)
-static void registry_global(void *data, struct wl_registry *registry,
- uint32_t name, const char *interface,
+static void registry_global(void * data, struct wl_registry * registry,
+ uint32_t name, const char * interface,
uint32_t version);
-static void registry_global_remove(void *data, struct wl_registry *registry,
+static void registry_global_remove(void * data, struct wl_registry * registry,
uint32_t name);
-static void shm_format(void *data, struct wl_shm *wl, uint32_t format);
+static void shm_format(void * data, struct wl_shm * wl, uint32_t format);
const static struct wl_registry_listener registry_listener = {
- .global = &registry_global, .global_remove = &registry_global_remove};
+ .global = &registry_global,
+ .global_remove = &registry_global_remove
+};
const static struct wl_shm_listener shm_listener = {
.format = &shm_format,
};
-static inline uint32_t format_wld_to_shm(uint32_t format) {
- switch (format) {
- case WLD_FORMAT_ARGB8888:
- return WL_SHM_FORMAT_ARGB8888;
- case WLD_FORMAT_XRGB8888:
- return WL_SHM_FORMAT_XRGB8888;
- default:
- return 0;
- }
+static inline uint32_t format_wld_to_shm(uint32_t format)
+{
+ switch (format)
+ {
+ case WLD_FORMAT_ARGB8888:
+ return WL_SHM_FORMAT_ARGB8888;
+ case WLD_FORMAT_XRGB8888:
+ return WL_SHM_FORMAT_XRGB8888;
+ default:
+ return 0;
+ }
}
-struct wayland_context *wayland_create_context(struct wl_display *display,
- struct wl_event_queue *queue) {
- struct shm_context *context;
+struct wayland_context * wayland_create_context(struct wl_display * display,
+ struct wl_event_queue * queue)
+{
+ struct shm_context * context;
- if (!(context = malloc(sizeof *context)))
- goto error0;
+ if (!(context = malloc(sizeof *context)))
+ goto error0;
- context_initialize(&context->base.base, &wld_context_impl);
- context->wl = NULL;
- wl_array_init(&context->formats);
+ context_initialize(&context->base.base, &wld_context_impl);
+ context->wl = NULL;
+ wl_array_init(&context->formats);
- if (!(context->registry = wl_display_get_registry(display))) {
- DEBUG("Couldn't get registry\n");
- goto error1;
- }
+ if (!(context->registry = wl_display_get_registry(display)))
+ {
+ DEBUG("Couldn't get registry\n");
+ goto error1;
+ }
- wl_registry_add_listener(context->registry, &registry_listener, context);
- wl_proxy_set_queue((struct wl_proxy *)context->registry, queue);
+ wl_registry_add_listener(context->registry, &registry_listener, context);
+ wl_proxy_set_queue((struct wl_proxy *) context->registry, queue);
- /* Wait for wl_shm global. */
- wl_display_roundtrip_queue(display, queue);
+ /* Wait for wl_shm global. */
+ wl_display_roundtrip_queue(display, queue);
- if (!context->wl) {
- DEBUG("No wl_shm global\n");
- goto error2;
- }
+ if (!context->wl)
+ {
+ DEBUG("No wl_shm global\n");
+ goto error2;
+ }
- wl_shm_add_listener(context->wl, &shm_listener, context);
+ wl_shm_add_listener(context->wl, &shm_listener, context);
- /* Wait for SHM formats. */
- wl_display_roundtrip_queue(display, queue);
+ /* Wait for SHM formats. */
+ wl_display_roundtrip_queue(display, queue);
- return &context->base;
+ return &context->base;
-error2:
- wl_registry_destroy(context->registry);
-error1:
- wl_array_release(&context->formats);
- free(context);
-error0:
- return NULL;
+ error2:
+ wl_registry_destroy(context->registry);
+ error1:
+ wl_array_release(&context->formats);
+ free(context);
+ error0:
+ return NULL;
}
-bool wayland_has_format(struct wld_context *base, uint32_t format) {
- struct shm_context *context = shm_context(base);
- uint32_t *supported_format;
- uint32_t shm_format = format_wld_to_shm(format);
+bool wayland_has_format(struct wld_context * base, uint32_t format)
+{
+ struct shm_context * context = shm_context(base);
+ uint32_t * supported_format;
+ uint32_t shm_format = format_wld_to_shm(format);
- wl_array_for_each(supported_format, &context->formats) {
- if (*supported_format == shm_format)
- return true;
- }
+ wl_array_for_each(supported_format, &context->formats)
+ {
+ if (*supported_format == shm_format)
+ return true;
+ }
- return false;
+ return false;
}
-struct wld_renderer *context_create_renderer(struct wld_context *context) {
- return wld_create_renderer(wld_pixman_context);
+struct wld_renderer * context_create_renderer(struct wld_context * context)
+{
+ return wld_create_renderer(wld_pixman_context);
}
-struct buffer *context_create_buffer(struct wld_context *base, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t flags) {
- struct shm_context *context = shm_context(base);
- struct shm_buffer *buffer;
- char name[] = "/tmp/wld-XXXXXX";
- uint32_t pitch = width * format_bytes_per_pixel(format);
- size_t size = pitch * height;
- int fd;
- struct wl_shm_pool *pool;
- struct wl_buffer *wl;
+struct buffer * context_create_buffer(struct wld_context * base,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags)
+{
+ struct shm_context * context = shm_context(base);
+ struct shm_buffer * buffer;
+ char name[] = "/tmp/wld-XXXXXX";
+ uint32_t pitch = width * format_bytes_per_pixel(format);
+ size_t size = pitch * height;
+ int fd;
+ struct wl_shm_pool * pool;
+ struct wl_buffer * wl;
- if (!wayland_has_format(base, format))
- goto error0;
+ if (!wayland_has_format(base, format))
+ goto error0;
- if (!(buffer = malloc(sizeof *buffer)))
- goto error0;
+ if (!(buffer = malloc(sizeof *buffer)))
+ goto error0;
- fd = mkostemp(name, O_CLOEXEC);
+ fd = mkostemp(name, O_CLOEXEC);
- if (fd < 0)
- goto error1;
+ if (fd < 0)
+ goto error1;
- unlink(name);
+ unlink(name);
- if (posix_fallocate(fd, 0, size) != 0)
- goto error2;
+ if (posix_fallocate(fd, 0, size) != 0)
+ goto error2;
- if (!(pool = wl_shm_create_pool(context->wl, fd, size)))
- goto error2;
+ if (!(pool = wl_shm_create_pool(context->wl, fd, size)))
+ goto error2;
- wl = wl_shm_pool_create_buffer(pool, 0, width, height, pitch,
- format_wld_to_shm(format));
- wl_shm_pool_destroy(pool);
+ wl = wl_shm_pool_create_buffer(pool, 0, width, height, pitch,
+ format_wld_to_shm(format));
+ wl_shm_pool_destroy(pool);
- if (!wl)
- goto error2;
+ if (!wl)
+ goto error2;
- buffer_initialize(&buffer->base, &wld_buffer_impl, width, height, format,
- pitch);
- buffer->fd = fd;
+ buffer_initialize(&buffer->base, &wld_buffer_impl,
+ width, height, format, pitch);
+ buffer->fd = fd;
- if (!(wayland_buffer_add_exporter(&buffer->base, wl)))
- goto error3;
+ if (!(wayland_buffer_add_exporter(&buffer->base, wl)))
+ goto error3;
- return &buffer->base;
+ return &buffer->base;
-error3:
- wl_buffer_destroy(wl);
-error2:
- close(fd);
-error1:
- free(buffer);
-error0:
- return NULL;
+ error3:
+ wl_buffer_destroy(wl);
+ error2:
+ close(fd);
+ error1:
+ free(buffer);
+ error0:
+ return NULL;
}
-struct buffer *context_import_buffer(struct wld_context *context, uint32_t type,
- union wld_object object, uint32_t width,
- uint32_t height, uint32_t format,
- uint32_t pitch) {
- return NULL;
+struct buffer * context_import_buffer(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch)
+{
+ return NULL;
}
-void context_destroy(struct wld_context *base) {
- struct shm_context *context = shm_context(base);
+void context_destroy(struct wld_context * base)
+{
+ struct shm_context * context = shm_context(base);
- wl_shm_destroy(context->wl);
- wl_registry_destroy(context->registry);
- wl_array_release(&context->formats);
- wl_event_queue_destroy(context->base.queue);
- free(context);
+ wl_shm_destroy(context->wl);
+ wl_registry_destroy(context->registry);
+ wl_array_release(&context->formats);
+ wl_event_queue_destroy(context->base.queue);
+ free(context);
}
/**** Buffer ****/
-bool buffer_map(struct buffer *base) {
- struct shm_buffer *buffer = shm_buffer(&base->base);
- void *data;
+bool buffer_map(struct buffer * base)
+{
+ struct shm_buffer * buffer = shm_buffer(&base->base);
+ void * data;
- data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
- PROT_READ | PROT_WRITE, MAP_SHARED, buffer->fd, 0);
+ data = mmap(NULL, buffer->base.base.pitch * buffer->base.base.height,
+ PROT_READ | PROT_WRITE, MAP_SHARED, buffer->fd, 0);
- if (data == MAP_FAILED)
- return false;
+ if (data == MAP_FAILED)
+ return false;
- buffer->base.base.map = data;
+ buffer->base.base.map = data;
- return true;
+ return true;
}
-bool buffer_unmap(struct buffer *buffer) {
- if (munmap(buffer->base.map, buffer->base.pitch * buffer->base.height) ==
- -1) {
- return false;
- }
+bool buffer_unmap(struct buffer * buffer)
+{
+ if (munmap(buffer->base.map,
+ buffer->base.pitch * buffer->base.height) == -1)
+ {
+ return false;
+ }
- buffer->base.map = NULL;
+ buffer->base.map = NULL;
- return true;
+ return true;
}
-void buffer_destroy(struct buffer *base) {
- struct shm_buffer *buffer = shm_buffer(&base->base);
+void buffer_destroy(struct buffer * base)
+{
+ struct shm_buffer * buffer = shm_buffer(&base->base);
- close(buffer->fd);
- free(buffer);
+ close(buffer->fd);
+ free(buffer);
}
-void registry_global(void *data, struct wl_registry *registry, uint32_t name,
- const char *interface, uint32_t version) {
- struct shm_context *context = data;
+void registry_global(void * data, struct wl_registry * registry, uint32_t name,
+ const char * interface, uint32_t version)
+{
+ struct shm_context * context = data;
- if (strcmp(interface, "wl_shm") == 0)
- context->wl = wl_registry_bind(registry, name, &wl_shm_interface, 1);
+ if (strcmp(interface, "wl_shm") == 0)
+ context->wl = wl_registry_bind(registry, name, &wl_shm_interface, 1);
}
-void registry_global_remove(void *data, struct wl_registry *registry,
- uint32_t name) {}
+void registry_global_remove(void * data, struct wl_registry * registry,
+ uint32_t name)
+{
+}
-void shm_format(void *data, struct wl_shm *wl, uint32_t format) {
- struct shm_context *context = data;
- uint32_t *added_format;
+void shm_format(void * data, struct wl_shm * wl, uint32_t format)
+{
+ struct shm_context * context = data;
+ uint32_t * added_format;
- if (!(added_format = wl_array_add(&context->formats, sizeof format)))
- return;
- *added_format = format;
+ if (!(added_format = wl_array_add(&context->formats, sizeof format)))
+ return;
+ *added_format = format;
}
+
diff --git a/src/wld/wayland.c b/src/wld/wayland.c
index 7cdd641..40a4b34 100644
--- a/src/wld/wayland.c
+++ b/src/wld/wayland.c
@@ -21,262 +21,288 @@
* SOFTWARE.
*/
-#include "wld/wayland.h"
-#include "wld/wayland-private.h"
-#include "wld/wld-private.h"
+#include "wayland.h"
+#include "wayland-private.h"
+#include "wld-private.h"
#include <stdlib.h>
#include <wayland-client.h>
-struct wayland_buffer {
- struct wld_exporter exporter;
- struct wld_destructor destructor;
- struct wl_buffer *wl;
+struct wayland_buffer
+{
+ struct wld_exporter exporter;
+ struct wld_destructor destructor;
+ struct wl_buffer * wl;
};
-struct wayland_buffer_socket {
- struct buffer_socket base;
- struct wl_buffer_listener listener;
- struct wld_surface *surface;
- struct wl_surface *wl;
- struct wl_display *display;
- struct wl_event_queue *queue;
+struct wayland_buffer_socket
+{
+ struct buffer_socket base;
+ struct wl_buffer_listener listener;
+ struct wld_surface * surface;
+ struct wl_surface * wl;
+ struct wl_display * display;
+ struct wl_event_queue * queue;
};
-static bool buffer_socket_attach(struct buffer_socket *socket,
- struct buffer *buffer);
-static void buffer_socket_process(struct buffer_socket *socket);
-static void buffer_socket_destroy(struct buffer_socket *socket);
+static bool buffer_socket_attach(struct buffer_socket * socket,
+ struct buffer * buffer);
+static void buffer_socket_process(struct buffer_socket * socket);
+static void buffer_socket_destroy(struct buffer_socket * socket);
static const struct buffer_socket_impl buffer_socket_impl = {
.attach = &buffer_socket_attach,
.process = &buffer_socket_process,
- .destroy = &buffer_socket_destroy};
+ .destroy = &buffer_socket_destroy
+};
IMPL(wayland_buffer_socket, buffer_socket)
-static void sync_done(void *data, struct wl_callback *callback, uint32_t msecs);
+static void sync_done(void * data, struct wl_callback * callback,
+ uint32_t msecs);
-static const struct wl_callback_listener sync_listener = {.done = &sync_done};
+static const struct wl_callback_listener sync_listener = {
+ .done = &sync_done
+};
-static void buffer_release(void *data, struct wl_buffer *buffer);
+static void buffer_release(void * data, struct wl_buffer * buffer);
-const static struct wayland_impl *impls[] = {
-/*
+const static struct wayland_impl * impls[] = {
#if WITH_WAYLAND_DRM
[WLD_DRM] = &drm_wayland_impl,
#endif
-*/
+
#if WITH_WAYLAND_SHM
[WLD_SHM] = &shm_wayland_impl,
#endif
};
-enum wld_wayland_interface_id interface_id(const char *string) {
- if (strcmp(string, "drm") == 0)
- return WLD_DRM;
- if (strcmp(string, "shm") == 0)
- return WLD_SHM;
+enum wld_wayland_interface_id interface_id(const char * string)
+{
+ if (strcmp(string, "drm") == 0)
+ return WLD_DRM;
+ if (strcmp(string, "shm") == 0)
+ return WLD_SHM;
- fprintf(stderr, "Unknown Wayland interface specified: '%s'\n", string);
+ fprintf(stderr, "Unknown Wayland interface specified: '%s'\n", string);
- return WLD_NONE;
+ return WLD_NONE;
}
EXPORT
-struct wld_context *wld_wayland_create_context(struct wl_display *display,
- enum wld_wayland_interface_id id,
- ...) {
- struct wayland_context *context = NULL;
- struct wl_event_queue *queue;
- va_list requested_impls;
- bool impls_tried[ARRAY_LENGTH(impls)] = {0};
- const char *interface_string;
-
- if (!(queue = wl_display_create_queue(display)))
- return NULL;
+struct wld_context * wld_wayland_create_context
+ (struct wl_display * display, enum wld_wayland_interface_id id, ...)
+{
+ struct wayland_context * context = NULL;
+ struct wl_event_queue * queue;
+ va_list requested_impls;
+ bool impls_tried[ARRAY_LENGTH(impls)] = {0};
+ const char * interface_string;
- if ((interface_string = getenv("WLD_WAYLAND_INTERFACE"))) {
- id = interface_id(interface_string);
+ if (!(queue = wl_display_create_queue(display)))
+ return NULL;
- if ((context = impls[id]->create_context(display, queue)))
- return &context->base;
+ if ((interface_string = getenv("WLD_WAYLAND_INTERFACE")))
+ {
+ id = interface_id(interface_string);
- fprintf(stderr, "Could not create context for Wayland interface '%s'\n",
- interface_string);
+ if ((context = impls[id]->create_context(display, queue)))
+ return &context->base;
- return NULL;
- }
+ fprintf(stderr, "Could not create context for Wayland interface '%s'\n",
+ interface_string);
- va_start(requested_impls, id);
+ return NULL;
+ }
+
+ va_start(requested_impls, id);
- while (id >= 0) {
- if (impls_tried[id] || !impls[id])
- continue;
+ while (id >= 0)
+ {
+ if (impls_tried[id] || !impls[id])
+ continue;
- if ((context = impls[id]->create_context(display, queue)))
- goto done;
+ if ((context = impls[id]->create_context(display, queue)))
+ goto done;
- impls_tried[id] = true;
- id = va_arg(requested_impls, enum wld_wayland_interface_id);
- }
+ impls_tried[id] = true;
+ id = va_arg(requested_impls, enum wld_wayland_interface_id);
+ }
- va_end(requested_impls);
+ va_end(requested_impls);
- /* If the user specified WLD_ANY, try any remaining implementations. */
- if (!context && id == WLD_ANY) {
- for (id = 0; id < ARRAY_LENGTH(impls); ++id) {
- if (impls_tried[id] || !impls[id])
- continue;
+ /* If the user specified WLD_ANY, try any remaining implementations. */
+ if (!context && id == WLD_ANY)
+ {
+ for (id = 0; id < ARRAY_LENGTH(impls); ++id)
+ {
+ if (impls_tried[id] || !impls[id])
+ continue;
- if ((context = impls[id]->create_context(display, queue)))
- break;
+ if ((context = impls[id]->create_context(display, queue)))
+ break;
+ }
}
- }
- if (!context) {
- DEBUG("Could not initialize any of the specified implementations\n");
- return NULL;
- }
+ if (!context)
+ {
+ DEBUG("Could not initialize any of the specified implementations\n");
+ return NULL;
+ }
-done:
- context->impl = impls[id];
- context->display = display;
- context->queue = queue;
+ done:
+ context->impl = impls[id];
+ context->display = display;
+ context->queue = queue;
- return &context->base;
+ return &context->base;
}
EXPORT
-struct wld_surface *wld_wayland_create_surface(struct wld_context *context,
- uint32_t width, uint32_t height,
- uint32_t format, uint32_t flags,
- struct wl_surface *wl) {
- struct wayland_buffer_socket *socket;
-
- if (!(socket = malloc(sizeof *socket)))
- goto error0;
-
- socket->base.impl = &buffer_socket_impl;
- socket->listener.release = &buffer_release;
- socket->wl = wl;
- socket->queue = ((struct wayland_context *)context)->queue;
- socket->display = ((struct wayland_context *)context)->display;
- socket->surface = buffered_surface_create(context, width, height, format,
- flags, &socket->base);
-
- if (!socket->surface)
- goto error1;
-
- return socket->surface;
-
-error1:
- free(socket);
-error0:
- return NULL;
+struct wld_surface * wld_wayland_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags,
+ struct wl_surface * wl)
+{
+ struct wayland_buffer_socket * socket;
+
+ if (!(socket = malloc(sizeof *socket)))
+ goto error0;
+
+ socket->base.impl = &buffer_socket_impl;
+ socket->listener.release = &buffer_release;
+ socket->wl = wl;
+ socket->queue = ((struct wayland_context *) context)->queue;
+ socket->display = ((struct wayland_context *) context)->display;
+ socket->surface = buffered_surface_create(context, width, height, format,
+ flags, &socket->base);
+
+ if (!socket->surface)
+ goto error1;
+
+ return socket->surface;
+
+ error1:
+ free(socket);
+ error0:
+ return NULL;
}
EXPORT
-bool wld_wayland_has_format(struct wld_context *base, uint32_t format) {
- struct wayland_context *context = (void *)base;
+bool wld_wayland_has_format(struct wld_context * base, uint32_t format)
+{
+ struct wayland_context * context = (void *) base;
- return context->impl->has_format(base, format);
+ return context->impl->has_format(base, format);
}
-static bool buffer_export(struct wld_exporter *exporter,
- struct wld_buffer *buffer, uint32_t type,
- union wld_object *object) {
- struct wayland_buffer *wayland_buffer =
- CONTAINER_OF(exporter, struct wayland_buffer, exporter);
-
- switch (type) {
- case WLD_WAYLAND_OBJECT_BUFFER:
- object->ptr = wayland_buffer->wl;
- return true;
- default:
- return false;
- }
+static bool buffer_export(struct wld_exporter * exporter,
+ struct wld_buffer * buffer,
+ uint32_t type, union wld_object * object)
+{
+ struct wayland_buffer * wayland_buffer
+ = CONTAINER_OF(exporter, struct wayland_buffer, exporter);
+
+ switch (type)
+ {
+ case WLD_WAYLAND_OBJECT_BUFFER:
+ object->ptr = wayland_buffer->wl;
+ return true;
+ default: return false;
+ }
}
-static void buffer_destroy(struct wld_destructor *destructor) {
- struct wayland_buffer *wayland_buffer =
- CONTAINER_OF(destructor, struct wayland_buffer, destructor);
+static void buffer_destroy(struct wld_destructor * destructor)
+{
+ struct wayland_buffer * wayland_buffer
+ = CONTAINER_OF(destructor, struct wayland_buffer, destructor);
- wl_buffer_destroy(wayland_buffer->wl);
- free(wayland_buffer);
+ wl_buffer_destroy(wayland_buffer->wl);
+ free(wayland_buffer);
}
-bool wayland_buffer_add_exporter(struct buffer *buffer, struct wl_buffer *wl) {
- struct wayland_buffer *wayland_buffer;
+bool wayland_buffer_add_exporter(struct buffer * buffer, struct wl_buffer * wl)
+{
+ struct wayland_buffer * wayland_buffer;
- if (!(wayland_buffer = malloc(sizeof *wayland_buffer)))
- return false;
+ if (!(wayland_buffer = malloc(sizeof *wayland_buffer)))
+ return false;
- wayland_buffer->wl = wl;
- wayland_buffer->exporter.export = &buffer_export;
- wld_buffer_add_exporter(&buffer->base, &wayland_buffer->exporter);
- wayland_buffer->destructor.destroy = &buffer_destroy;
- wld_buffer_add_destructor(&buffer->base, &wayland_buffer->destructor);
+ wayland_buffer->wl = wl;
+ wayland_buffer->exporter.export = &buffer_export;
+ wld_buffer_add_exporter(&buffer->base, &wayland_buffer->exporter);
+ wayland_buffer->destructor.destroy = &buffer_destroy;
+ wld_buffer_add_destructor(&buffer->base, &wayland_buffer->destructor);
- return true;
+ return true;
}
-bool buffer_socket_attach(struct buffer_socket *base, struct buffer *buffer) {
- struct wayland_buffer_socket *socket = wayland_buffer_socket(base);
- struct wl_buffer *wl;
- union wld_object object;
+bool buffer_socket_attach(struct buffer_socket * base, struct buffer * buffer)
+{
+ struct wayland_buffer_socket * socket = wayland_buffer_socket(base);
+ struct wl_buffer * wl;
+ union wld_object object;
- if (!wld_export(&buffer->base, WLD_WAYLAND_OBJECT_BUFFER, &object))
- return false;
+ if (!wld_export(&buffer->base, WLD_WAYLAND_OBJECT_BUFFER, &object))
+ return false;
- wl = object.ptr;
+ wl = object.ptr;
- if (!wl_proxy_get_listener((struct wl_proxy *)wl))
- wl_buffer_add_listener(wl, &socket->listener, buffer);
+ if (!wl_proxy_get_listener((struct wl_proxy *) wl))
+ wl_buffer_add_listener(wl, &socket->listener, buffer);
- wl_surface_attach(socket->wl, wl, 0, 0);
+ wl_surface_attach(socket->wl, wl, 0, 0);
- if (pixman_region32_not_empty(&buffer->base.damage)) {
- pixman_box32_t *box;
- int num_boxes;
+ if (pixman_region32_not_empty(&buffer->base.damage))
+ {
+ pixman_box32_t * box;
+ int num_boxes;
- box = pixman_region32_rectangles(&buffer->base.damage, &num_boxes);
+ box = pixman_region32_rectangles(&buffer->base.damage, &num_boxes);
- while (num_boxes--) {
- wl_surface_damage(socket->wl, box->x1, box->y1, box->x2 - box->x1,
- box->y2 - box->y1);
+ while (num_boxes--)
+ {
+ wl_surface_damage(socket->wl, box->x1, box->y1,
+ box->x2 - box->x1, box->y2 - box->y1);
+ }
}
- }
- wl_surface_commit(socket->wl);
+ wl_surface_commit(socket->wl);
- return true;
+ return true;
}
-void buffer_socket_process(struct buffer_socket *base) {
- struct wayland_buffer_socket *socket = wayland_buffer_socket(base);
+void buffer_socket_process(struct buffer_socket * base)
+{
+ struct wayland_buffer_socket * socket = wayland_buffer_socket(base);
- /* Since events for our wl_buffers lie in a special queue used by WLD, we
- * must dispatch these events here so that we see any release events before
- * the next back buffer is chosen. */
- wl_display_dispatch_queue_pending(socket->display, socket->queue);
+ /* Since events for our wl_buffers lie in a special queue used by WLD, we
+ * must dispatch these events here so that we see any release events before
+ * the next back buffer is chosen. */
+ wl_display_dispatch_queue_pending(socket->display, socket->queue);
}
-void buffer_socket_destroy(struct buffer_socket *socket) { free(socket); }
+void buffer_socket_destroy(struct buffer_socket * socket)
+{
+ free(socket);
+}
-void sync_done(void *data, struct wl_callback *callback, uint32_t msecs) {
- bool *done = data;
+void sync_done(void * data, struct wl_callback * callback, uint32_t msecs)
+{
+ bool * done = data;
- *done = true;
- wl_callback_destroy(callback);
+ *done = true;
+ wl_callback_destroy(callback);
}
-void buffer_release(void *data, struct wl_buffer *wl) {
- struct wld_buffer *buffer = data;
- const struct wl_buffer_listener *listener =
- wl_proxy_get_listener((struct wl_proxy *)wl);
- struct wayland_buffer_socket *socket =
- CONTAINER_OF(listener, struct wayland_buffer_socket, listener);
+void buffer_release(void * data, struct wl_buffer * wl)
+{
+ struct wld_buffer * buffer = data;
+ const struct wl_buffer_listener * listener
+ = wl_proxy_get_listener((struct wl_proxy *) wl);
+ struct wayland_buffer_socket * socket
+ = CONTAINER_OF(listener, struct wayland_buffer_socket, listener);
- wld_surface_release(socket->surface, buffer);
+ wld_surface_release(socket->surface, buffer);
}
+
diff --git a/src/wld/wayland.h b/src/wld/wayland.h
new file mode 100644
index 0000000..3127ee6
--- /dev/null
+++ b/src/wld/wayland.h
@@ -0,0 +1,84 @@
+/* wld: wayland.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_WAYLAND_H
+#define WLD_WAYLAND_H
+
+#include <stdbool.h>
+#include <stdint.h>
+
+struct wl_display;
+struct wl_surface;
+
+#define WLD_WAYLAND_ID (0x3 << 24)
+
+enum wld_wayland_interface_id
+{
+ /**
+ * Give up on trying any new interfaces. This can be considered as a
+ * sentinel for wld_wayland_create_context.
+ */
+ WLD_NONE = -2,
+
+ /**
+ * Try any available interface.
+ */
+ WLD_ANY = -1,
+ WLD_DRM,
+ WLD_SHM
+};
+
+enum wld_wayland_object_type
+{
+ WLD_WAYLAND_OBJECT_BUFFER = WLD_WAYLAND_ID
+};
+
+/**
+ * Create a new WLD context which uses various available Wayland interfaces
+ * (such as wl_shm and wl_drm) to create wl_buffers backed by implementations
+ * specific to the interface.
+ *
+ * You can specify the particular interface you want to use by specifying them
+ * as arguments. Interfaces will be tried in the order they are given.
+ *
+ * The last argument must be either WLD_NONE or WLD_ANY.
+ *
+ * @see enum wld_wayland_interface_id
+ */
+struct wld_context * wld_wayland_create_context
+ (struct wl_display * display, enum wld_wayland_interface_id id, ...);
+
+struct wld_surface * wld_wayland_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags,
+ struct wl_surface * surface);
+
+/**
+ * Check if the wayland implementation supports a particular pixel format.
+ *
+ * @see enum wld_format
+ */
+bool wld_wayland_has_format(struct wld_context * context, uint32_t format);
+
+#endif
+
diff --git a/src/wld/wld-private.h b/src/wld/wld-private.h
new file mode 100644
index 0000000..e812b11
--- /dev/null
+++ b/src/wld/wld-private.h
@@ -0,0 +1,243 @@
+/* wld: wld-private.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_PRIVATE_H
+#define WLD_PRIVATE_H
+
+#include "wld.h"
+
+#include <assert.h>
+#include <stdbool.h>
+#include <stdint.h>
+#include <ft2build.h>
+#include FT_FREETYPE_H
+#include FT_BITMAP_H
+
+#define ARRAY_LENGTH(array) (sizeof (array) / sizeof (array)[0])
+#if ENABLE_DEBUG
+# define DEBUG(format, ...) \
+ fprintf(stderr, "# %s: " format, __func__, ## __VA_ARGS__)
+#else
+# define DEBUG(format, ...)
+#endif
+
+#define EXPORT __attribute__((visibility("default")))
+#define CONTAINER_OF(ptr, type, member) \
+ ((type *)((uintptr_t) ptr - offsetof(type, member)))
+#define IMPL(impl_type, base_type) \
+ static inline struct impl_type * impl_type(struct base_type * object) \
+ { \
+ assert(object->impl == &base_type ## _impl); \
+ return (struct impl_type *) object; \
+ }
+
+struct wld_font_context
+{
+ FT_Library library;
+};
+
+struct glyph
+{
+ FT_Bitmap bitmap;
+
+ /**
+ * The offset from the origin to the top left corner of the bitmap.
+ */
+ int16_t x, y;
+
+ /**
+ * The width to advance to the origin of the next character.
+ */
+ uint16_t advance;
+};
+
+struct font
+{
+ struct wld_font base;
+
+ struct wld_font_context * context;
+ FT_Face face;
+ struct glyph ** glyphs;
+};
+
+struct wld_context_impl
+{
+ struct wld_renderer * (* create_renderer)(struct wld_context * context);
+ struct buffer * (* create_buffer)(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags);
+ struct buffer * (* import_buffer)(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch);
+ struct wld_surface * (* create_surface)(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags);
+ void (* destroy)(struct wld_context * context);
+};
+
+struct wld_renderer_impl
+{
+ uint32_t (* capabilities)(struct wld_renderer * renderer,
+ struct buffer * buffer);
+ bool (* set_target)(struct wld_renderer * renderer, struct buffer * buffer);
+ void (* fill_rectangle)(struct wld_renderer * renderer,
+ uint32_t color, int32_t x, int32_t y,
+ uint32_t width, uint32_t height);
+ void (* fill_region)(struct wld_renderer * renderer,
+ uint32_t color, pixman_region32_t * region);
+ void (* copy_rectangle)(struct wld_renderer * renderer, struct buffer * src,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height);
+ void (* copy_region)(struct wld_renderer * renderer, struct buffer * src,
+ int32_t dst_x, int32_t dst_y,
+ pixman_region32_t * region);
+ void (* draw_text)(struct wld_renderer * renderer,
+ struct font * font, uint32_t color,
+ int32_t x, int32_t y, const char * text, uint32_t length,
+ struct wld_extents * extents);
+ void (* flush)(struct wld_renderer * renderer);
+ void (* destroy)(struct wld_renderer * renderer);
+};
+
+struct buffer
+{
+ struct wld_buffer base;
+
+ unsigned references, map_references;
+ struct wld_exporter * exporters;
+ struct wld_destructor * destructors;
+};
+
+struct wld_buffer_impl
+{
+ bool (* map)(struct buffer * buffer);
+ bool (* unmap)(struct buffer * buffer);
+ void (* destroy)(struct buffer * buffer);
+};
+
+struct wld_surface_impl
+{
+ pixman_region32_t * (* damage)(struct wld_surface * surface,
+ pixman_region32_t * damage);
+ struct buffer * (* back)(struct wld_surface * surface);
+ struct buffer * (* take)(struct wld_surface * surface);
+ bool (* release)(struct wld_surface * surface, struct buffer * buffer);
+ bool (* swap)(struct wld_surface * surface);
+ void (* destroy)(struct wld_surface * surface);
+};
+
+struct buffer_socket
+{
+ const struct buffer_socket_impl * impl;
+};
+
+struct buffer_socket_impl
+{
+ bool (* attach)(struct buffer_socket * socket, struct buffer * buffer);
+ void (* process)(struct buffer_socket * socket);
+ void (* destroy)(struct buffer_socket * socket);
+};
+
+bool font_ensure_glyph(struct font * font, FT_UInt glyph_index);
+
+/**
+ * Returns the number of bytes per pixel for the given format.
+ */
+static inline uint8_t format_bytes_per_pixel(enum wld_format format)
+{
+ switch (format)
+ {
+ case WLD_FORMAT_ARGB8888:
+ case WLD_FORMAT_XRGB8888:
+ return 4;
+ default:
+ return 0;
+ }
+}
+
+static inline pixman_format_code_t format_wld_to_pixman(uint32_t format)
+{
+ switch (format)
+ {
+ case WLD_FORMAT_ARGB8888:
+ return PIXMAN_a8r8g8b8;
+ case WLD_FORMAT_XRGB8888:
+ return PIXMAN_x8r8g8b8;
+ default:
+ return 0;
+ }
+}
+
+static inline uint32_t format_pixman_to_wld(pixman_format_code_t format)
+{
+ switch (format)
+ {
+ case PIXMAN_a8r8g8b8:
+ return WLD_FORMAT_ARGB8888;
+ case PIXMAN_x8r8g8b8:
+ return WLD_FORMAT_XRGB8888;
+ default:
+ return 0;
+ }
+}
+
+/**
+ * This default fill_region method is implemented in terms of fill_rectangle.
+ */
+void default_fill_region(struct wld_renderer * renderer, uint32_t color,
+ pixman_region32_t * region);
+
+/**
+ * This default copy_region method is implemented in terms of copy_rectangle.
+ */
+void default_copy_region(struct wld_renderer * renderer, struct buffer * buffer,
+ int32_t dst_x, int32_t dst_y,
+ pixman_region32_t * region);
+
+struct wld_surface * default_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags);
+
+struct wld_surface * buffered_surface_create(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags,
+ struct buffer_socket * socket);
+
+void context_initialize(struct wld_context * context,
+ const struct wld_context_impl * impl);
+
+void renderer_initialize(struct wld_renderer * renderer,
+ const struct wld_renderer_impl * impl);
+
+void buffer_initialize(struct buffer * buffer,
+ const struct wld_buffer_impl * impl,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch);
+
+void surface_initialize(struct wld_surface * surface,
+ const struct wld_surface_impl * impl);
+
+#endif
+
diff --git a/src/wld/wld.h b/src/wld/wld.h
new file mode 100644
index 0000000..452b1a5
--- /dev/null
+++ b/src/wld/wld.h
@@ -0,0 +1,284 @@
+/* wld: wld.h
+ *
+ * Copyright (c) 2013, 2014 Michael Forney
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+
+#ifndef WLD_H
+#define WLD_H
+
+#include <stdbool.h>
+#include <stdint.h>
+#include <pixman.h>
+#include <fontconfig/fontconfig.h>
+
+#define WLD_USER_ID (0xff << 24)
+
+#define __WLD_FOURCC(a, b, c, d) ( (a) \
+ | ((b) << 8) \
+ | ((c) << 16) \
+ | ((d) << 24) )
+
+/**
+ * Supported pixel formats.
+ *
+ * These formats can safely be interchanged with GBM and wl_drm formats.
+ */
+enum wld_format
+{
+ WLD_FORMAT_XRGB8888 = __WLD_FOURCC('X', 'R', '2', '4'),
+ WLD_FORMAT_ARGB8888 = __WLD_FOURCC('A', 'R', '2', '4')
+};
+
+enum wld_flags
+{
+ WLD_FLAG_MAP = 1 << 16,
+ WLD_FLAG_CURSOR = 1 << 17,
+};
+
+bool wld_lookup_named_color(const char * name, uint32_t * color);
+
+/**** WLD Context ****/
+
+enum wld_object_type
+{
+ WLD_OBJECT_DATA
+};
+
+union wld_object
+{
+ void * ptr;
+ uint32_t u32;
+ int i;
+};
+
+struct wld_context
+{
+ const struct wld_context_impl * const impl;
+};
+
+struct wld_renderer * wld_create_renderer(struct wld_context * context);
+
+struct wld_buffer * wld_create_buffer(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags);
+
+struct wld_buffer * wld_import_buffer(struct wld_context * context,
+ uint32_t type, union wld_object object,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t pitch);
+
+struct wld_surface * wld_create_surface(struct wld_context * context,
+ uint32_t width, uint32_t height,
+ uint32_t format, uint32_t flags);
+
+void wld_destroy_context(struct wld_context * context);
+
+/**** Font Handling ****/
+
+struct wld_extents
+{
+ uint32_t advance;
+};
+
+struct wld_font
+{
+ uint32_t ascent, descent;
+ uint32_t height;
+ uint32_t max_advance;
+};
+
+/**
+ * Create a new font context.
+ *
+ * This sets up the underlying FreeType library.
+ */
+struct wld_font_context * wld_font_create_context();
+
+/**
+ * Destroy a font context.
+ */
+void wld_font_destroy_context(struct wld_font_context * context);
+
+/**
+ * Open a new font from the given fontconfig match.
+ */
+struct wld_font * wld_font_open_pattern(struct wld_font_context * context,
+ FcPattern * match);
+
+/**
+ * Open a new font from a fontconfig pattern string.
+ */
+struct wld_font * wld_font_open_name(struct wld_font_context * context,
+ const char * name);
+
+/**
+ * Close a font.
+ */
+void wld_font_close(struct wld_font * font);
+
+/**
+ * Check if the given font has a particular character (in UTF-32), and if so,
+ * load the glyph.
+ */
+bool wld_font_ensure_char(struct wld_font * font, uint32_t character);
+
+/**
+ * Calculate the text extents of the given UTF-8 string.
+ *
+ * @param length The maximum number of bytes in the string to process
+ */
+void wld_font_text_extents_n(struct wld_font * font,
+ const char * text, int32_t length,
+ struct wld_extents * extents);
+
+static inline void wld_font_text_extents(struct wld_font * font,
+ const char * text,
+ struct wld_extents * extents)
+{
+ wld_font_text_extents_n(font, text, INT32_MAX, extents);
+}
+
+/**** Buffers ****/
+
+struct wld_exporter
+{
+ bool (* export)(struct wld_exporter * exporter, struct wld_buffer * buffer,
+ uint32_t type, union wld_object * object);
+ struct wld_exporter * next;
+};
+
+struct wld_destructor
+{
+ void (* destroy)(struct wld_destructor * destructor);
+ struct wld_destructor * next;
+};
+
+struct wld_buffer
+{
+ const struct wld_buffer_impl * const impl;
+
+ uint32_t width, height, pitch;
+ enum wld_format format;
+ pixman_region32_t damage;
+ void * map;
+};
+
+bool wld_map(struct wld_buffer * buffer);
+bool wld_unmap(struct wld_buffer * buffer);
+
+bool wld_export(struct wld_buffer * buffer,
+ uint32_t type, union wld_object * object);
+
+void wld_buffer_add_exporter(struct wld_buffer * buffer,
+ struct wld_exporter * exporter);
+
+void wld_buffer_add_destructor(struct wld_buffer * buffer,
+ struct wld_destructor * destructor);
+
+/**
+ * Increase the reference count of a buffer.
+ */
+void wld_buffer_reference(struct wld_buffer * buffer);
+
+/**
+ * Decrease the reference count of a buffer.
+ *
+ * When the reference count drops to zero, the buffer will be destroyed.
+ */
+void wld_buffer_unreference(struct wld_buffer * buffer);
+
+/**** Surfaces ****/
+
+struct wld_surface
+{
+ const struct wld_surface_impl * const impl;
+};
+
+pixman_region32_t * wld_surface_damage(struct wld_surface * surface,
+ pixman_region32_t * new_damage);
+
+struct wld_buffer * wld_surface_take(struct wld_surface * surface);
+
+void wld_surface_release(struct wld_surface * surface,
+ struct wld_buffer * buffer);
+
+bool wld_swap(struct wld_surface * surface);
+
+void wld_destroy_surface(struct wld_surface * surface);
+
+/**** Renderers ****/
+
+struct wld_renderer
+{
+ const struct wld_renderer_impl * const impl;
+ struct wld_buffer * target;
+};
+
+enum wld_capability
+{
+ WLD_CAPABILITY_READ = 1<<0,
+ WLD_CAPABILITY_WRITE = 1<<1,
+};
+
+void wld_destroy_renderer(struct wld_renderer * renderer);
+
+uint32_t wld_capabilities(struct wld_renderer * renderer,
+ struct wld_buffer * buffer);
+
+bool wld_set_target_buffer(struct wld_renderer * renderer,
+ struct wld_buffer * buffer);
+
+bool wld_set_target_surface(struct wld_renderer * renderer,
+ struct wld_surface * surface);
+
+void wld_fill_rectangle(struct wld_renderer * renderer, uint32_t color,
+ int32_t x, int32_t y, uint32_t width, uint32_t height);
+
+void wld_fill_region(struct wld_renderer * renderer, uint32_t color,
+ pixman_region32_t * region);
+
+void wld_copy_rectangle(struct wld_renderer * renderer,
+ struct wld_buffer * buffer,
+ int32_t dst_x, int32_t dst_y,
+ int32_t src_x, int32_t src_y,
+ uint32_t width, uint32_t height);
+
+void wld_copy_region(struct wld_renderer * renderer,
+ struct wld_buffer * buffer,
+ int32_t dst_x, int32_t dst_y, pixman_region32_t * region);
+
+/**
+ * Draw a UTF-8 text string to the given buffer.
+ *
+ * @param length The maximum number of bytes in the string to process. If
+ * length is -1, then draw until a NULL byte is found.
+ * @param extents If not NULL, will be initialized to the extents of the
+ * drawn text
+ */
+void wld_draw_text(struct wld_renderer * renderer,
+ struct wld_font * font, uint32_t color,
+ int32_t x, int32_t y, const char * text, uint32_t length,
+ struct wld_extents * extents);
+
+void wld_flush(struct wld_renderer * renderer);
+
+#endif
+