From 876331fc77f6763c8c390d1289ead00f89f8d9fe Mon Sep 17 00:00:00 2001
From: "Mike J. Chen" <mjchen@google.com>
Date: Tue, 16 Oct 2012 19:15:47 -0700
Subject: Merged hwc with TI mainline version

Change-Id: I8390a3422c6ff8fa4bc4c0e6a11c51a884aba3cb
Signed-off-by: Mike J. Chen <mjchen@google.com>
---
 hwc/rgz_2d.c | 1528 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 1528 insertions(+)
 create mode 100644 hwc/rgz_2d.c

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
new file mode 100644
index 0000000..7f95a78
--- /dev/null
+++ b/hwc/rgz_2d.c
@@ -0,0 +1,1528 @@
+/*
+ * Copyright (C) Texas Instruments - http://www.ti.com/
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <stdio.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <time.h>
+#include <assert.h>
+#include <strings.h>
+#include <dlfcn.h>
+
+#include <fcntl.h>
+#include <sys/mman.h>
+#include <linux/fb.h>
+#include <linux/bltsville.h>
+#include <video/dsscomp.h>
+#include <video/omap_hwc.h>
+
+#ifndef RGZ_TEST_INTEGRATION
+#include <cutils/log.h>
+#include <cutils/properties.h>
+#include <hardware/hwcomposer.h>
+#include "hal_public.h"
+#else
+#include "hwcomposer.h"
+#include "buffer_handle.h"
+#define ALIGN(x,a) (((x) + (a) - 1L) & ~((a) - 1L))
+#define HW_ALIGN   32
+#endif
+
+#include "rgz_2d.h"
+
+#ifdef RGZ_TEST_INTEGRATION
+extern void BVDump(const char* prefix, const char* tab, const struct bvbltparams* parms);
+#define BVDUMP(p,t,parms) BVDump(p, t, parms)
+#define HANDLE_TO_BUFFER(h) handle_to_buffer(h)
+#define HANDLE_TO_STRIDE(h) handle_to_stride(h)
+#else
+static int rgz_handle_to_stride(IMG_native_handle_t *h);
+#define BVDUMP(p,t,parms)
+#define HANDLE_TO_BUFFER(h) NULL
+/* Needs to be meaningful for TILER & GFX buffers and NV12 */
+#define HANDLE_TO_STRIDE(h) rgz_handle_to_stride(h)
+#endif
+#define DSTSTRIDE(dstgeom) dstgeom->virtstride
+
+/* Borrowed macros from hwc.c vvv - consider sharing later */
+#define min(a, b) ( { typeof(a) __a = (a), __b = (b); __a < __b ? __a : __b; } )
+#define max(a, b) ( { typeof(a) __a = (a), __b = (b); __a > __b ? __a : __b; } )
+#define swap(a, b) do { typeof(a) __a = (a); (a) = (b); (b) = __a; } while (0)
+
+#define WIDTH(rect) ((rect).right - (rect).left)
+#define HEIGHT(rect) ((rect).bottom - (rect).top)
+
+#define is_RGB(format) ((format) == HAL_PIXEL_FORMAT_BGRA_8888 || (format) == HAL_PIXEL_FORMAT_RGB_565 || (format) == HAL_PIXEL_FORMAT_BGRX_8888)
+#define is_BGR(format) ((format) == HAL_PIXEL_FORMAT_RGBX_8888 || (format) == HAL_PIXEL_FORMAT_RGBA_8888)
+#define is_NV12(format) ((format) == HAL_PIXEL_FORMAT_TI_NV12 || (format) == HAL_PIXEL_FORMAT_TI_NV12_PADDED)
+
+#define HAL_PIXEL_FORMAT_BGRX_8888 0x1FF
+#define HAL_PIXEL_FORMAT_TI_NV12 0x100
+#define HAL_PIXEL_FORMAT_TI_NV12_PADDED 0x101
+/* Borrowed macros from hwc.c ^^^ */
+#define is_OPAQUE(format) ((format) == HAL_PIXEL_FORMAT_RGB_565 || (format) == HAL_PIXEL_FORMAT_RGBX_8888 || (format) == HAL_PIXEL_FORMAT_BGRX_8888)
+
+/* OUTP the means for grabbing diagnostic data */
+#ifndef RGZ_TEST_INTEGRATION
+#define OUTP ALOGI
+#define OUTE ALOGE
+#else
+#define OUTP(...) { printf(__VA_ARGS__); printf("\n"); fflush(stdout); }
+#define OUTE OUTP
+#define ALOGD_IF(debug, ...) { if (debug) OUTP(__VA_ARGS__); }
+#endif
+
+#define IS_BVCMD(params) (params->op == RGZ_OUT_BVCMD_REGION || params->op == RGZ_OUT_BVCMD_PAINT)
+
+/* Number of framebuffers to track */
+#define RGZ_NUM_FB 2
+
+struct rgz_blts {
+    struct rgz_blt_entry bvcmds[RGZ_MAX_BLITS];
+    int idx;
+};
+
+
+static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff_idx);
+static void rgz_blts_init(struct rgz_blts *blts);
+static void rgz_blts_free(struct rgz_blts *blts);
+static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params);
+static int rgz_blts_bvdirect(rgz_t* rgz, struct rgz_blts *blts, rgz_out_params_t *params);
+
+int debug = 0;
+struct rgz_blts blts;
+/* Represents a screen sized background layer */
+static hwc_layer_t bg_layer;
+
+static void svgout_header(int htmlw, int htmlh, int coordw, int coordh)
+{
+    OUTP("<svg xmlns=\"http://www.w3.org/2000/svg\""
+         "width=\"%d\" height=\"%d\""
+         "viewBox=\"0 0 %d %d\">",
+        htmlw, htmlh, coordw, coordh);
+}
+
+static void svgout_footer(void)
+{
+    OUTP("</svg>");
+}
+
+static void svgout_rect(blit_rect_t *r, char *color, char *text)
+{
+    OUTP("<rect x=\"%d\" y=\"%d\" width=\"%d\" height=\"%d\" fill=\"%s\" "
+         "fill-opacity=\"%f\" stroke=\"black\" stroke-width=\"1\" />",
+         r->left, r->top, r->right - r->left, r->bottom - r->top, color, 1.0f);
+
+    if (!text)
+        return;
+
+    OUTP("<text x=\"%d\" y=\"%d\" style=\"font-size:30\" fill=\"black\">%s"
+         "</text>",
+         r->left, r->top + 40, text);
+}
+
+static int empty_rect(blit_rect_t *r)
+{
+    return !((((r->left == r->top) == r->right) == r->bottom) == 0);
+}
+
+static int get_top_rect(blit_hregion_t *hregion, int subregion, blit_rect_t **routp)
+{
+    int l = hregion->nlayers - 1;
+    do {
+        *routp = &hregion->blitrects[l][subregion];
+        if (!empty_rect(*routp))
+            break;
+    }
+    while (--l >= 0);
+    return l;
+}
+
+/*
+ * The idea here is that we walk the layers from front to back and count the
+ * number of layers in the hregion until the first layer which doesn't require
+ * blending.
+ */
+static int get_layer_ops(blit_hregion_t *hregion, int subregion, int *bottom)
+{
+    int l = hregion->nlayers - 1;
+    int ops = 0;
+    *bottom = -1;
+    do {
+        if (!empty_rect(&hregion->blitrects[l][subregion])) {
+            ops++;
+            *bottom = l;
+            hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+            IMG_native_handle_t *h = (IMG_native_handle_t *)layer->handle;
+            if ((layer->blending != HWC_BLENDING_PREMULT) || is_OPAQUE(h->iFormat))
+                break;
+        }
+    }
+    while (--l >= 0);
+    return ops;
+}
+
+static int get_layer_ops_next(blit_hregion_t *hregion, int subregion, int l)
+{
+    while (++l < hregion->nlayers) {
+        if (!empty_rect(&hregion->blitrects[l][subregion]))
+            return l;
+    }
+    return -1;
+}
+
+static int svgout_intersects_display(blit_rect_t *a, int dispw, int disph)
+{
+    return ((a->bottom > 0) && (a->top < disph) &&
+            (a->right > 0) && (a->left < dispw));
+}
+
+static void svgout_hregion(blit_hregion_t *hregion, int dispw, int disph)
+{
+    char *colors[] = {"red", "orange", "yellow", "green", "blue", "indigo", "violet", NULL};
+    int b;
+    for (b = 0; b < hregion->nsubregions; b++) {
+        blit_rect_t *rect;
+        (void)get_top_rect(hregion, b, &rect);
+        /* Only generate SVG for subregions intersecting the displayed area */
+        if (!svgout_intersects_display(rect, dispw, disph))
+            continue;
+        svgout_rect(rect, colors[b % 7], NULL);
+    }
+}
+
+static void rgz_out_svg(rgz_t *rgz, rgz_out_params_t *params)
+{
+    if (!rgz || !(rgz->state & RGZ_REGION_DATA)) {
+        OUTE("rgz_out_svg invoked with bad state");
+        return;
+    }
+    blit_hregion_t *hregions = rgz->hregions;
+    svgout_header(params->data.svg.htmlw, params->data.svg.htmlh,
+                  params->data.svg.dispw, params->data.svg.disph);
+    int i;
+    for (i = 0; i < rgz->nhregions; i++) {
+
+        OUTP("<!-- hregion %d (subcount %d)-->", i, hregions[i].nsubregions);
+        svgout_hregion(&hregions[i], params->data.svg.dispw,
+                       params->data.svg.disph);
+    }
+    svgout_footer();
+}
+
+/* XXX duplicate of hwc.c version */
+static void dump_layer(hwc_layer_t const* l, int iserr)
+{
+#define FMT(f) ((f) == HAL_PIXEL_FORMAT_TI_NV12 ? "NV12" : \
+                (f) == HAL_PIXEL_FORMAT_BGRX_8888 ? "xRGB32" : \
+                (f) == HAL_PIXEL_FORMAT_RGBX_8888 ? "xBGR32" : \
+                (f) == HAL_PIXEL_FORMAT_BGRA_8888 ? "ARGB32" : \
+                (f) == HAL_PIXEL_FORMAT_RGBA_8888 ? "ABGR32" : \
+                (f) == HAL_PIXEL_FORMAT_RGB_565 ? "RGB565" : "??")
+
+    OUTE("%stype=%d, flags=%08x, handle=%p, tr=%02x, blend=%04x, {%d,%d,%d,%d}, {%d,%d,%d,%d}",
+            iserr ? ">>  " : "    ",
+            l->compositionType, l->flags, l->handle, l->transform, l->blending,
+            l->sourceCrop.left,
+            l->sourceCrop.top,
+            l->sourceCrop.right,
+            l->sourceCrop.bottom,
+            l->displayFrame.left,
+            l->displayFrame.top,
+            l->displayFrame.right,
+            l->displayFrame.bottom);
+    if (l->handle) {
+        IMG_native_handle_t *h = (IMG_native_handle_t *)l->handle;
+        OUTE("%s%d*%d(%s)",
+            iserr ? ">>  " : "    ",
+            h->iWidth, h->iHeight, FMT(h->iFormat));
+        OUTE("hndl %p", l->handle);
+    }
+}
+
+static void dump_all(rgz_layer_t *rgz_layers, unsigned int layerno, unsigned int errlayer)
+{
+    unsigned int i;
+    for (i = 0; i < layerno; i++) {
+        hwc_layer_t *l = rgz_layers[i].hwc_layer;
+        OUTE("Layer %d", i);
+        dump_layer(l, errlayer == i);
+    }
+}
+
+static int rgz_out_bvdirect_paint(rgz_t *rgz, rgz_out_params_t *params)
+{
+    int rv = 0;
+    unsigned int i;
+    (void)rgz;
+
+    rgz_blts_init(&blts);
+
+    /* Begin from index 1 to remove the background layer from the output */
+    for (i = 1; i < rgz->rgz_layerno; i++) {
+        hwc_layer_t *l = rgz->rgz_layers[i].hwc_layer;
+
+        rv = rgz_hwc_layer_blit(l, params, -1);
+        if (rv) {
+            OUTE("bvdirect_paint: error in layer %d: %d", i, rv);
+            dump_all(rgz->rgz_layers, rgz->rgz_layerno, i);
+            rgz_blts_free(&blts);
+            return rv;
+        }
+    }
+    rgz_blts_bvdirect(rgz, &blts, params);
+    rgz_blts_free(&blts);
+    return rv;
+}
+
+/*
+ * Clear the destination buffer, if rect is NULL means the whole screen, rect
+ * cannot be outside the boundaries of the screen
+ */
+static void rgz_out_clrdst(rgz_out_params_t *params, blit_rect_t *rect)
+{
+    struct bvsurfgeom *scrgeom = params->data.bvc.dstgeom;
+
+    struct rgz_blt_entry* e;
+    e = rgz_blts_get(&blts, params);
+
+    struct bvbuffdesc *src1desc = &e->src1desc;
+    src1desc->structsize = sizeof(struct bvbuffdesc);
+    src1desc->length = 4;
+    /*
+     * With the HWC we don't bother having a buffer for the fill we'll get the
+     * OMAPLFB to fixup the src1desc if this address is -1
+     */
+    src1desc->auxptr = (void*)-1;
+    struct bvsurfgeom *src1geom = &e->src1geom;
+    src1geom->structsize = sizeof(struct bvsurfgeom);
+    src1geom->format = OCDFMT_RGBA24;
+    src1geom->width = src1geom->height = 1;
+    src1geom->orientation = 0;
+    src1geom->virtstride = 1;
+
+    struct bvsurfgeom *dstgeom = &e->dstgeom;
+    dstgeom->structsize = sizeof(struct bvsurfgeom);
+    dstgeom->format = scrgeom->format;
+    dstgeom->width = scrgeom->width;
+    dstgeom->height = scrgeom->height;
+    dstgeom->orientation = 0; /* TODO */
+    dstgeom->virtstride = DSTSTRIDE(scrgeom);
+
+    struct bvbltparams *bp = &e->bp;
+    bp->structsize = sizeof(struct bvbltparams);
+    bp->dstgeom = dstgeom;
+    bp->src1.desc = src1desc;
+    bp->src1geom = src1geom;
+    bp->src1rect.left = 0;
+    bp->src1rect.top = 0;
+    bp->src1rect.width = bp->src1rect.height = 1;
+    bp->cliprect.left = bp->dstrect.left = rect ? rect->left : 0;
+    bp->cliprect.top = bp->dstrect.top = rect ? rect->top : 0;
+    bp->cliprect.width = bp->dstrect.width = rect ? (unsigned int) WIDTH(*rect) : scrgeom->width;
+    bp->cliprect.height = bp->dstrect.height = rect ? (unsigned int) HEIGHT(*rect) : scrgeom->height;
+
+    bp->flags = BVFLAG_CLIP | BVFLAG_ROP;
+    bp->op.rop = 0xCCCC; /* SRCCOPY */
+}
+
+static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
+{
+    int rv = 0;
+    params->data.bvc.out_blits = 0;
+    params->data.bvc.out_nhndls = 0;
+    rgz_blts_init(&blts);
+    rgz_out_clrdst(params, NULL);
+
+    unsigned int i;
+
+    /* Begin from index 1 to remove the background layer from the output */
+    for (i = 1; i < rgz->rgz_layerno; i++) {
+        hwc_layer_t *l = rgz->rgz_layers[i].hwc_layer;
+
+        //OUTP("blitting meminfo %d", rgz->rgz_layers[i].buffidx);
+
+        rv = rgz_hwc_layer_blit(l, params, rgz->rgz_layers[i].buffidx);
+        if (rv) {
+            OUTE("bvcmd_paint: error in layer %d: %d", i, rv);
+            dump_all(rgz->rgz_layers, rgz->rgz_layerno, i);
+            rgz_blts_free(&blts);
+            return rv;
+        }
+        params->data.bvc.out_hndls[i-1] = l->handle;
+        params->data.bvc.out_nhndls++;
+    }
+
+    /* FIXME: we want to be able to call rgz_blts_free and populate the actual
+     * composition data structure ourselves */
+    params->data.bvc.cmdp = blts.bvcmds;
+    params->data.bvc.cmdlen = blts.idx;
+
+    if (params->data.bvc.out_blits >= RGZ_MAX_BLITS) {
+        rv = -1;
+    // rgz_blts_free(&blts); // FIXME
+    }
+    return rv;
+}
+
+static float getscalew(hwc_layer_t *layer)
+{
+    int w = WIDTH(layer->sourceCrop);
+    int h = HEIGHT(layer->sourceCrop);
+
+    if (layer->transform & HWC_TRANSFORM_ROT_90)
+        swap(w, h);
+
+    return ((float)WIDTH(layer->displayFrame)) / (float)w;
+}
+
+static float getscaleh(hwc_layer_t *layer)
+{
+    int w = WIDTH(layer->sourceCrop);
+    int h = HEIGHT(layer->sourceCrop);
+
+    if (layer->transform & HWC_TRANSFORM_ROT_90)
+        swap(w, h);
+
+    return ((float)HEIGHT(layer->displayFrame)) / (float)h;
+}
+
+static int rgz_bswap(int *a, int *b)
+{
+    if (*a > *b) {
+        int tmp = *b;
+        *b = *a;
+        *a = tmp;
+        return 1;
+    }
+    return 0;
+}
+
+/*
+ * Simple bubble sort on an array
+ */
+static void rgz_bsort(int *a, int len)
+{
+    int i, s;
+
+    do {
+        s=0;
+        for (i=0; i+1<len; i++) {
+            if (rgz_bswap(&a[i], &a[i+1]))
+                s = 1;
+        }
+    } while (s);
+}
+
+/*
+ * Leave only unique numbers in a sorted array
+ */
+static int rgz_bunique(int *a, int len)
+{
+    int unique = 1;
+    int base = 0;
+    while (base + 1 < len) {
+        if (a[base] == a[base + 1]) {
+            int skip = 1;
+            while (base + skip < len && a[base] == a[base + skip])
+                skip++;
+            if (base + skip == len)
+                break;
+            int i;
+            for (i = 0; i < skip - 1; i++)
+                a[base + 1 + i] = a[base + skip];
+        }
+        unique++;
+        base++;
+    }
+    return unique;
+}
+
+static int rgz_hwc_layer_sortbyy(rgz_layer_t *ra, int rsz, int *out, int *width, int screen_height)
+{
+    int outsz = 0;
+    int i;
+    *width = 0;
+    for (i = 0; i < rsz; i++) {
+        hwc_layer_t *layer = ra[i].hwc_layer;
+        /* Maintain regions inside display boundaries */
+        int top = layer->displayFrame.top;
+        int bottom = layer->displayFrame.bottom;
+        out[outsz++] = max(0, top);
+        out[outsz++] = min(bottom, screen_height);
+        int right = layer->displayFrame.right;
+        *width = *width > right ? *width : right;
+    }
+    rgz_bsort(out, outsz);
+    return outsz;
+}
+
+static int rgz_hwc_intersects(blit_rect_t *a, hwc_rect_t *b)
+{
+    return ((a->bottom > b->top) && (a->top < b->bottom) &&
+            (a->right > b->left) && (a->left < b->right));
+}
+
+static void rgz_gen_blitregions(blit_hregion_t *hregion, int screen_width)
+{
+/*
+ * 1. Get the offsets (left/right positions) of each layer within the
+ *    hregion. Assume that layers describe the bounds of the hregion.
+ * 2. We should then be able to generate an array of rects
+ * 3. Each layer will have a different z-order, for each z-order
+ *    find the intersection. Some intersections will be empty.
+ */
+
+    int offsets[RGZ_SUBREGIONMAX];
+    int noffsets=0;
+    int l, r;
+    for (l = 0; l < hregion->nlayers; l++) {
+        hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+        /* Make sure the subregion is not outside the boundaries of the screen */
+        int left = layer->displayFrame.left;
+        int right = layer->displayFrame.right;
+        offsets[noffsets++] = max(0, left);
+        offsets[noffsets++] = min(right, screen_width);
+    }
+    rgz_bsort(offsets, noffsets);
+    noffsets = rgz_bunique(offsets, noffsets);
+    hregion->nsubregions = noffsets - 1;
+    bzero(hregion->blitrects, sizeof(hregion->blitrects));
+    for (r = 0; r + 1 < noffsets; r++) {
+        blit_rect_t subregion;
+        subregion.top = hregion->rect.top;
+        subregion.bottom = hregion->rect.bottom;
+        subregion.left = offsets[r];
+        subregion.right = offsets[r+1];
+
+        ALOGD_IF(debug, "                sub l %d r %d",
+            subregion.left, subregion.right);
+        for (l = 0; l < hregion->nlayers; l++) {
+            hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+            if (rgz_hwc_intersects(&subregion, &layer->displayFrame)) {
+
+                hregion->blitrects[l][r] = subregion;
+
+                ALOGD_IF(debug, "hregion->blitrects[%d][%d] (%d %d %d %d)", l, r,
+                        hregion->blitrects[l][r].left,
+                        hregion->blitrects[l][r].top,
+                        hregion->blitrects[l][r].right,
+                        hregion->blitrects[l][r].bottom);
+            }
+        }
+    }
+}
+
+static int rgz_hwc_scaled(hwc_layer_t *layer)
+{
+    int w = WIDTH(layer->sourceCrop);
+    int h = HEIGHT(layer->sourceCrop);
+
+    if (layer->transform & HWC_TRANSFORM_ROT_90)
+        swap(w, h);
+
+    return WIDTH(layer->displayFrame) != w || HEIGHT(layer->displayFrame) != h;
+}
+
+static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
+{
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+    if ((layer->flags & HWC_SKIP_LAYER) || !handle)
+        return 0;
+
+    if (is_NV12(handle->iFormat) || layer->transform || rgz_hwc_scaled(layer))
+        return 0;
+
+    switch(handle->iFormat) {
+    case HAL_PIXEL_FORMAT_BGRX_8888:
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+    case HAL_PIXEL_FORMAT_RGB_565:
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+        break;
+    default:
+        return 0;
+    }
+    return 1;
+}
+
+static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
+{
+    hwc_layer_t *layers = p->data.hwc.layers;
+    int layerno = p->data.hwc.layerno;
+
+    rgz->state &= ~RGZ_STATE_INIT;
+
+    if (!layers)
+        return -1;
+
+    /* For debugging */
+    //dump_all(layers, layerno, 0);
+
+    /*
+     * Store buffer index to be sent in the HWC Post2 list. Any overlay
+     * meminfos must come first
+     */
+    int l, memidx = 0;
+    for (l = 0; l < layerno; l++) {
+        if (layers[l].compositionType == HWC_OVERLAY)
+            memidx++;
+    }
+
+    int possible_blit = 0, candidates = 0;
+    rgz->screen_isdirty = 1;
+
+    /* Insert the background layer at the beginning of the list */
+    rgz->rgz_layers[0].hwc_layer = &bg_layer;
+
+    for (l = 0; l < layerno; l++) {
+        if (layers[l].compositionType == HWC_FRAMEBUFFER) {
+            candidates++;
+            if (rgz_in_valid_hwc_layer(&layers[l]) &&
+                    possible_blit < RGZ_INPUT_MAXLAYERS) {
+                rgz_layer_t *rgz_layer = &rgz->rgz_layers[possible_blit+1];
+                rgz_layer->hwc_layer = &layers[l];
+                rgz_layer->buffidx = memidx++;
+                if (rgz_layer->hwc_layer->handle != rgz_layer->dirty_hndl) {
+                    rgz_layer->dirty_count = RGZ_NUM_FB;
+                    rgz_layer->dirty_hndl = (void*)rgz_layer->hwc_layer->handle;
+                } else {
+                     rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
+                     if (rgz_layer->dirty_count == 0)
+                         rgz->screen_isdirty = 0; /* Just update dirty regions from now on */
+                }
+                possible_blit++;
+            }
+        }
+    }
+
+    if (!possible_blit || possible_blit != candidates) {
+        return -1;
+    }
+
+    rgz->state |= RGZ_STATE_INIT;
+    rgz->rgz_layerno = possible_blit + 1; /* Account for background layer */
+
+    return RGZ_ALL;
+}
+
+static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz)
+{
+    int yentries[RGZ_SUBREGIONMAX];
+    int dispw;  /* widest layer */
+    int screen_width = p->data.hwc.dstgeom->width;
+    int screen_height = p->data.hwc.dstgeom->height;
+
+    if (!(rgz->state & RGZ_STATE_INIT)) {
+        OUTE("rgz_process started with bad state");
+        return -1;
+    }
+
+    /* If there is already region data avoid parsing it again */
+    if (rgz->state & RGZ_REGION_DATA) {
+        return 0;
+    }
+
+    int layerno = rgz->rgz_layerno;
+
+    /* Find the horizontal regions */
+    rgz_layer_t *rgz_layers = rgz->rgz_layers;
+    int ylen = rgz_hwc_layer_sortbyy(rgz_layers, layerno, yentries, &dispw, screen_height);
+
+    ylen = rgz_bunique(yentries, ylen);
+
+    /* at this point we have an array of horizontal regions */
+    rgz->nhregions = ylen - 1;
+
+    blit_hregion_t *hregions = calloc(rgz->nhregions, sizeof(blit_hregion_t));
+    if (!hregions) {
+        OUTE("Unable to allocate memory for hregions");
+        return -1;
+    }
+    rgz->hregions = hregions;
+
+    ALOGD_IF(debug, "Allocated %d regions (sz = %d), layerno = %d", rgz->nhregions, rgz->nhregions * sizeof(blit_hregion_t), layerno);
+    int i, j;
+    for (i = 0; i < rgz->nhregions; i++) {
+        hregions[i].rect.top = yentries[i];
+        hregions[i].rect.bottom = yentries[i+1];
+        /* Avoid hregions outside the display boundaries */
+        hregions[i].rect.left = 0;
+        hregions[i].rect.right = dispw > screen_width ? screen_width : dispw;
+        hregions[i].nlayers = 0;
+        for (j = 0; j < layerno; j++) {
+            hwc_layer_t *layer = rgz_layers[j].hwc_layer;
+            if (rgz_hwc_intersects(&hregions[i].rect, &layer->displayFrame)) {
+                int l = hregions[i].nlayers++;
+                hregions[i].rgz_layers[l] = &rgz_layers[j];
+            }
+        }
+    }
+
+    /* Calculate blit regions */
+    for (i = 0; i < rgz->nhregions; i++) {
+        rgz_gen_blitregions(&hregions[i], screen_width);
+        ALOGD_IF(debug, "hregion %3d: nsubregions %d", i, hregions[i].nsubregions);
+        ALOGD_IF(debug, "           : %d to %d: ",
+            hregions[i].rect.top, hregions[i].rect.bottom);
+        for (j = 0; j < hregions[i].nlayers; j++)
+            ALOGD_IF(debug, "              %p ", hregions[i].rgz_layers[j]->hwc_layer);
+    }
+    rgz->state |= RGZ_REGION_DATA;
+    return 0;
+}
+
+/*
+ * generate a human readable description of the layer
+ *
+ * idx, flags, fmt, type, sleft, stop, sright, sbot, dleft, dtop, \
+ * dright, dbot, rot, flip, blending, scalew, scaleh, visrects
+ *
+ */
+static void rgz_print_layer(hwc_layer_t *l, int idx, int csv)
+{
+    char big_log[1024];
+    int e = sizeof(big_log);
+    char *end = big_log + e;
+    e -= snprintf(end - e, e, "<!-- LAYER-DAT: %d", idx);
+
+
+    e -= snprintf(end - e, e, "%s %p", csv ? "," : " hndl:",
+            l->handle ? l->handle : NULL);
+
+    e -= snprintf(end - e, e, "%s %s", csv ? "," : " flags:",
+        l->flags & HWC_SKIP_LAYER ? "skip" : "none");
+
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
+    if (handle) {
+        e -= snprintf(end - e, e, "%s", csv ? ", " : " fmt: ");
+        switch(handle->iFormat) {
+        case HAL_PIXEL_FORMAT_BGRA_8888:
+            e -= snprintf(end - e, e, "bgra"); break;
+        case HAL_PIXEL_FORMAT_RGB_565:
+            e -= snprintf(end - e, e, "rgb565"); break;
+        case HAL_PIXEL_FORMAT_BGRX_8888:
+            e -= snprintf(end - e, e, "bgrx"); break;
+        case HAL_PIXEL_FORMAT_RGBX_8888:
+            e -= snprintf(end - e, e, "rgbx"); break;
+        case HAL_PIXEL_FORMAT_RGBA_8888:
+            e -= snprintf(end - e, e, "rgba"); break;
+        case HAL_PIXEL_FORMAT_TI_NV12:
+        case HAL_PIXEL_FORMAT_TI_NV12_PADDED:
+            e -= snprintf(end - e, e, "nv12"); break;
+        default:
+            e -= snprintf(end - e, e, "unknown");
+        }
+        e -= snprintf(end - e, e, "%s", csv ? ", " : " type: ");
+        if (handle->usage & GRALLOC_USAGE_HW_RENDER)
+            e -= snprintf(end - e, e, "hw");
+        else if (handle->usage & GRALLOC_USAGE_SW_READ_MASK ||
+                 handle->usage & GRALLOC_USAGE_SW_WRITE_MASK)
+            e -= snprintf(end - e, e, "sw");
+        else
+            e -= snprintf(end - e, e, "unknown");
+    } else {
+        e -= snprintf(end - e, e, csv ? ", unknown" : " fmt: unknown");
+        e -= snprintf(end - e, e, csv ? ", na" : " type: na");
+    }
+    e -= snprintf(end - e, e, csv ? ", %d, %d, %d, %d" : " src: %d %d %d %d",
+        l->sourceCrop.left, l->sourceCrop.top, l->sourceCrop.right,
+        l->sourceCrop.bottom);
+    e -= snprintf(end - e, e, csv ? ", %d, %d, %d, %d" : " disp: %d %d %d %d",
+        l->displayFrame.left, l->displayFrame.top,
+        l->displayFrame.right, l->displayFrame.bottom);
+
+    e -= snprintf(end - e, e, "%s %s", csv ? "," : " rot:",
+        l->transform & HWC_TRANSFORM_ROT_90 ? "90" :
+            l->transform & HWC_TRANSFORM_ROT_180 ? "180" :
+            l->transform & HWC_TRANSFORM_ROT_270 ? "270" : "none");
+
+    char flip[5] = "";
+    strcat(flip, l->transform & HWC_TRANSFORM_FLIP_H ? "H" : "");
+    strcat(flip, l->transform & HWC_TRANSFORM_FLIP_V ? "V" : "");
+    if (!(l->transform & (HWC_TRANSFORM_FLIP_V|HWC_TRANSFORM_FLIP_H)))
+        strcpy(flip, "none");
+    e -= snprintf(end - e, e, "%s %s", csv ? "," : " flip:", flip);
+
+    e -= snprintf(end - e, e, "%s %s", csv ? "," : " blending:",
+        l->blending == HWC_BLENDING_NONE ? "none" :
+        l->blending == HWC_BLENDING_PREMULT ? "premult" :
+        l->blending == HWC_BLENDING_COVERAGE ? "coverage" : "invalid");
+
+    e -= snprintf(end - e, e, "%s %1.3f", csv ? "," : " scalew:", getscalew(l));
+    e -= snprintf(end - e, e, "%s %1.3f", csv ? "," : " scaleh:", getscaleh(l));
+
+    e -= snprintf(end - e, e, "%s %d", csv ? "," : " visrect:",
+        l->visibleRegionScreen.numRects);
+
+    if (!csv) {
+        e -= snprintf(end - e, e, " -->");
+        OUTP("%s", big_log);
+
+        size_t i = 0;
+        for (; i < l->visibleRegionScreen.numRects; i++) {
+            hwc_rect_t const *r = &l->visibleRegionScreen.rects[i];
+            OUTP("<!-- LAYER-VIS: %d: rect: %d %d %d %d -->",
+                    i, r->left, r->top, r->right, r->bottom);
+        }
+    } else {
+        size_t i = 0;
+        for (; i < l->visibleRegionScreen.numRects; i++) {
+            hwc_rect_t const *r = &l->visibleRegionScreen.rects[i];
+            e -= snprintf(end - e, e, ", %d, %d, %d, %d",
+                    r->left, r->top, r->right, r->bottom);
+        }
+        e -= snprintf(end - e, e, " -->");
+        OUTP("%s", big_log);
+    }
+}
+
+static void rgz_print_layers(hwc_layer_list_t* list, int csv)
+{
+    size_t i;
+    for (i = 0; i < list->numHwLayers; i++) {
+        hwc_layer_t *l = &list->hwLayers[i];
+        rgz_print_layer(l, i, csv);
+    }
+}
+
+static int hal_to_ocd(int color)
+{
+    switch(color) {
+    case HAL_PIXEL_FORMAT_BGRA_8888:
+        return OCDFMT_BGRA24;
+    case HAL_PIXEL_FORMAT_BGRX_8888:
+        return OCDFMT_BGR124;
+    case HAL_PIXEL_FORMAT_RGB_565:
+        return OCDFMT_RGB16;
+    case HAL_PIXEL_FORMAT_RGBA_8888:
+        return OCDFMT_RGBA24;
+    case HAL_PIXEL_FORMAT_RGBX_8888:
+        return OCDFMT_RGB124;
+    case HAL_PIXEL_FORMAT_TI_NV12:
+        return OCDFMT_NV12;
+    case HAL_PIXEL_FORMAT_YV12:
+        return OCDFMT_YV12;
+    default:
+        return OCDFMT_UNKNOWN;
+    }
+}
+
+/*
+ * The loadbltsville fn is only needed for testing, the bltsville shared
+ * libraries aren't planned to be used directly in production code here
+ */
+static BVFN_MAP bv_map;
+static BVFN_BLT bv_blt;
+static BVFN_UNMAP bv_unmap;
+#ifndef RGZ_TEST_INTEGRATION
+gralloc_module_t const *gralloc;
+#endif
+#define BLTSVILLELIB "libbltsville_cpu.so"
+
+#ifdef RGZ_TEST_INTEGRATION
+static int loadbltsville(void)
+{
+    void *hndl = dlopen(BLTSVILLELIB, RTLD_LOCAL | RTLD_LAZY);
+    if (!hndl) {
+        OUTE("Loading bltsville failed");
+        return -1;
+    }
+    bv_map = (BVFN_MAP)dlsym(hndl, "bv_map");
+    bv_blt = (BVFN_BLT)dlsym(hndl, "bv_blt");
+    bv_unmap = (BVFN_UNMAP)dlsym(hndl, "bv_unmap");
+    if(!bv_blt || !bv_map || !bv_unmap) {
+        OUTE("Missing bltsville fn %p %p %p", bv_map, bv_blt, bv_unmap);
+        return -1;
+    }
+    OUTP("Loaded %s", BLTSVILLELIB);
+
+#ifndef RGZ_TEST_INTEGRATION
+    hw_module_t const* module;
+    int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
+    if (err != 0) {
+        OUTE("Loading gralloc failed");
+        return -1;
+    }
+    gralloc = (gralloc_module_t const *)module;
+#endif
+    return 0;
+}
+#else
+static int loadbltsville(void) {
+    return 0;
+}
+#endif
+
+#ifndef RGZ_TEST_INTEGRATION
+static int rgz_handle_to_stride(IMG_native_handle_t *h)
+{
+    int bpp = is_NV12(h->iFormat) ? 0 : (h->iFormat == HAL_PIXEL_FORMAT_RGB_565 ? 2 : 4);
+    int stride = ALIGN(h->iWidth, HW_ALIGN) * bpp;
+    return stride;
+}
+
+#endif
+
+extern void BVDump(const char* prefix, const char* tab, const struct bvbltparams* parms);
+
+static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff_idx)
+{
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
+    if (!handle || l->flags & HWC_SKIP_LAYER) {
+        /*
+         * This shouldn't happen regionizer should reject compositions w/ skip
+         * layers
+         */
+        OUTP("Cannot handle skip layers\n");
+        return -1;
+    }
+    static int loaded = 0;
+    if (!loaded)
+        loaded = loadbltsville() ? : 1; /* attempt load once */
+
+    struct bvbuffdesc *scrdesc;
+    struct bvsurfgeom *scrgeom;
+    int noblend;
+
+    if (IS_BVCMD(params)) {
+        scrdesc = NULL;
+        scrgeom = params->data.bvc.dstgeom;
+        noblend = params->data.bvc.noblend;
+    } else {
+        scrdesc = params->data.bv.dstdesc;
+        scrgeom = params->data.bv.dstgeom;
+        noblend = params->data.bv.noblend;
+    }
+
+    struct rgz_blt_entry* e;
+    e = rgz_blts_get(&blts, params);
+
+    struct bvbuffdesc *src1desc = &e->src1desc;
+    src1desc->structsize = sizeof(struct bvbuffdesc);
+    src1desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
+    /*
+     * The virtaddr isn't going to be used in the final 2D h/w integration
+     * because we will be handling buffers differently
+     */
+    src1desc->auxptr = buff_idx == -1 ? HANDLE_TO_BUFFER(handle) : (void*)buff_idx; /* FIXME: revisit this later */
+
+    struct bvsurfgeom *src1geom = &e->src1geom;
+    src1geom->structsize = sizeof(struct bvsurfgeom);
+    src1geom->format = hal_to_ocd(handle->iFormat);
+    src1geom->width = handle->iWidth;
+    src1geom->height = handle->iHeight;
+    src1geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
+            l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
+            l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
+    src1geom->virtstride = HANDLE_TO_STRIDE(handle);
+
+    struct bvsurfgeom *dstgeom = &e->dstgeom;
+    dstgeom->structsize = sizeof(struct bvsurfgeom);
+    dstgeom->format = scrgeom->format;
+    dstgeom->width = scrgeom->width;
+    dstgeom->height = scrgeom->height;
+    dstgeom->orientation = 0; /* TODO */
+    dstgeom->virtstride = DSTSTRIDE(scrgeom);
+
+    struct bvbltparams *bp = &e->bp;
+    bp->structsize = sizeof(struct bvbltparams);
+    bp->dstdesc = scrdesc;
+    bp->dstgeom = dstgeom;
+    bp->dstrect.left = l->displayFrame.left;
+    bp->dstrect.top = l->displayFrame.top;
+    bp->dstrect.width = WIDTH(l->displayFrame);
+    bp->dstrect.height = HEIGHT(l->displayFrame);
+    bp->src1.desc = src1desc;
+    bp->src1geom = src1geom;
+    bp->src1rect.left = l->sourceCrop.left;
+    bp->src1rect.top = l->sourceCrop.top;
+    bp->src1rect.width = WIDTH(l->sourceCrop);
+    bp->src1rect.height = HEIGHT(l->sourceCrop);
+    bp->cliprect.left = bp->cliprect.top = 0;
+    bp->cliprect.width = scrgeom->width;
+    bp->cliprect.height = scrgeom->height;
+
+    unsigned long bpflags = BVFLAG_CLIP;
+    if (!noblend && l->blending == HWC_BLENDING_PREMULT) {
+        struct bvsurfgeom *src2geom = &e->src2geom;
+        struct bvbuffdesc *src2desc = &e->src2desc;
+        *src2geom = *dstgeom;
+        src2desc->structsize = sizeof(struct bvbuffdesc);
+        src2desc->auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
+        bpflags |= BVFLAG_BLEND;
+        bp->op.blend = BVBLEND_SRC1OVER;
+        bp->src2.desc = scrdesc;
+        bp->src2geom = dstgeom;
+        bp->src2rect.left = l->displayFrame.left;
+        bp->src2rect.top = l->displayFrame.top;
+        bp->src2rect.width = WIDTH(l->displayFrame);
+        bp->src2rect.height = HEIGHT(l->displayFrame);
+    } else {
+        bpflags |= BVFLAG_ROP;
+        bp->op.rop = 0xCCCC; /* SRCCOPY */
+        if((src1geom->format == OCDFMT_BGR124) ||
+           (src1geom->format == OCDFMT_RGB124) ||
+           (src1geom->format == OCDFMT_RGB16))
+            dstgeom->format = OCDFMT_BGR124;
+    }
+
+    /* TODO regionizer won't permit transforms yet */
+    if (l->transform & HWC_TRANSFORM_FLIP_H)
+        bpflags |= BVFLAG_HORZ_FLIP_SRC1;
+    if (l->transform & HWC_TRANSFORM_FLIP_V)
+        bpflags |= BVFLAG_VERT_FLIP_SRC1;
+
+    bp->flags = bpflags;
+
+    return 0;
+}
+
+/*
+ * Calculate the left coord of the source on the basis of the location of the
+ * blit subregion relative to the HWC layer display frame
+ */
+static int effective_srcleft(hwc_layer_t* l, blit_rect_t *rect)
+{
+    // Assert rect->left >= l->sourceCrop.left
+    // Assert rect->left < l->sourceCrop.left + WIDTH(l->sourceCrop)
+    return l->sourceCrop.left + ((WIDTH(l->sourceCrop) * (rect->left - l->displayFrame.left)) / WIDTH(l->displayFrame));
+}
+
+static int effective_srctop(hwc_layer_t* l, blit_rect_t *rect)
+{
+    // Assert rect->top >= l->sourceCrop.top
+    // Assert rect->top < l->sourceCrop.top + HEIGHT(l->sourceCrop)
+    return l->sourceCrop.top + ((HEIGHT(l->sourceCrop) * (rect->top - l->displayFrame.top)) / HEIGHT(l->displayFrame));
+}
+
+/*
+ * Setup the src2 rectangle and the passed descriptor and
+ * geometry
+ */
+static void rgz_src2blend_prep2(
+    struct rgz_blt_entry* e, unsigned int hwc_transform, blit_rect_t *rect,
+    struct bvbuffdesc *dstdesc, struct bvsurfgeom *dstgeom, int is_fb_dest)
+{
+    unsigned long bpflags = BVFLAG_CLIP;
+
+    struct bvbltparams *bp = &e->bp;
+    bpflags |= BVFLAG_BLEND; // FIXME batch?
+    bp->op.blend = BVBLEND_SRC1OVER;
+    bp->src2.desc = dstdesc;
+    bp->src2geom = dstgeom;
+    bp->src2rect.left = rect->left;
+    bp->src2rect.top = rect->top;
+    bp->src2rect.width = WIDTH(*rect);
+    bp->src2rect.height = HEIGHT(*rect);
+
+    if (is_fb_dest) {
+        struct bvsurfgeom *src2geom = &e->src2geom;
+        struct bvbuffdesc *src2desc = &e->src2desc;
+        *src2geom = *dstgeom;
+        src2desc->structsize = sizeof(struct bvbuffdesc);
+        src2desc->auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
+    }
+
+    if (hwc_transform & HWC_TRANSFORM_FLIP_H)
+        bpflags |= BVFLAG_HORZ_FLIP_SRC1;
+    if (hwc_transform & HWC_TRANSFORM_FLIP_V)
+        bpflags |= BVFLAG_VERT_FLIP_SRC1;
+
+    bp->flags = bpflags;
+}
+
+static void rgz_src2blend_prep(
+    struct rgz_blt_entry* e, rgz_layer_t *rgz_layer, blit_rect_t *rect, rgz_out_params_t *params)
+{
+    hwc_layer_t *l = rgz_layer->hwc_layer;
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
+
+    struct bvbuffdesc *src2desc = &e->src2desc;
+    src2desc->structsize = sizeof(struct bvbuffdesc);
+    src2desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
+    src2desc->auxptr = IS_BVCMD(params)?
+        (void*)rgz_layer->buffidx : HANDLE_TO_BUFFER(handle);
+
+    struct bvsurfgeom *src2geom = &e->src2geom;
+    src2geom->structsize = sizeof(struct bvsurfgeom);
+    src2geom->format = hal_to_ocd(handle->iFormat);
+    src2geom->width = handle->iWidth;
+    src2geom->height = handle->iHeight;
+    src2geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
+        l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
+        l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
+    src2geom->virtstride = HANDLE_TO_STRIDE(handle);
+
+    /*
+     * This looks a little odd but what we need to do here is take the
+     * rectangle which has coordinates in terms of the display dimensions
+     * and find the offset of the source buffer for the layer
+     */
+    blit_rect_t src2rect = *rect;
+    src2rect.top = effective_srctop(l, rect);
+    src2rect.left = effective_srcleft(l, rect);
+    src2rect.bottom = src2rect.top + HEIGHT(*rect);
+    src2rect.right = src2rect.left + WIDTH(*rect);
+    rgz_src2blend_prep2(e, l->transform, &src2rect, src2desc, src2geom, 0);
+}
+
+static void rgz_src1_prep(
+    struct rgz_blt_entry* e, rgz_layer_t *rgz_layer,
+    blit_rect_t *rect,
+    struct bvbuffdesc *scrdesc, struct bvsurfgeom *scrgeom, rgz_out_params_t *params)
+{
+    hwc_layer_t *l = rgz_layer->hwc_layer;
+    if (!l)
+        return;
+
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
+
+    struct bvbuffdesc *src1desc = &e->src1desc;
+    src1desc->structsize = sizeof(struct bvbuffdesc);
+    src1desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
+    src1desc->auxptr = IS_BVCMD(params) ?
+        (void*)rgz_layer->buffidx : HANDLE_TO_BUFFER(handle);
+
+    struct bvsurfgeom *src1geom = &e->src1geom;
+    src1geom->structsize = sizeof(struct bvsurfgeom);
+    src1geom->format = hal_to_ocd(handle->iFormat);
+    src1geom->width = handle->iWidth;
+    src1geom->height = handle->iHeight;
+    src1geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
+            l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
+            l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
+    src1geom->virtstride = HANDLE_TO_STRIDE(handle);
+
+    struct bvsurfgeom *dstgeom = &e->dstgeom;
+    dstgeom->structsize = sizeof(struct bvsurfgeom);
+    dstgeom->format = scrgeom->format;
+    dstgeom->width = scrgeom->width;
+    dstgeom->height = scrgeom->height;
+    dstgeom->orientation = 0;
+    dstgeom->virtstride = DSTSTRIDE(scrgeom);
+
+    struct bvbltparams *bp = &e->bp;
+    bp->structsize = sizeof(struct bvbltparams);
+    bp->dstdesc = scrdesc;
+    bp->dstgeom = dstgeom;
+    bp->dstrect.left = rect->left;
+    bp->dstrect.top = rect->top;
+    bp->dstrect.width = WIDTH(*rect);
+    bp->dstrect.height = HEIGHT(*rect);
+    bp->src1.desc = src1desc;
+    bp->src1geom = src1geom;
+    bp->src1rect.left = effective_srcleft(l, rect);
+    bp->src1rect.top = effective_srctop(l, rect);
+    bp->src1rect.width = WIDTH(*rect); // XXX fixme - effective width/height?
+    bp->src1rect.height = HEIGHT(*rect);
+    bp->cliprect.left = bp->cliprect.top = 0;
+    bp->cliprect.width = scrgeom->width;
+    bp->cliprect.height = scrgeom->height;
+}
+
+static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned int set)
+{
+    e->bp.flags &= ~BVFLAG_BATCH_MASK;
+    e->bp.flags |= flag;
+    e->bp.batchflags |= set;
+}
+
+static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_params_t *params, int screen_isdirty)
+{
+    static int loaded = 0;
+    if (!loaded)
+        loaded = loadbltsville() ? : 1; /* attempt load once */
+
+    struct bvbuffdesc *scrdesc;
+    struct bvsurfgeom *scrgeom;
+    int noblend;
+
+    if (IS_BVCMD(params)) {
+        scrdesc = NULL;
+        scrgeom = params->data.bvc.dstgeom;
+        noblend = params->data.bvc.noblend;
+    } else {
+        scrdesc = params->data.bv.dstdesc;
+        scrgeom = params->data.bv.dstgeom;
+        noblend = params->data.bv.noblend;
+    }
+
+    int lix;
+    int ldepth = get_layer_ops(hregion, sidx, &lix);
+    if (ldepth == 0) {
+        /* Impossible, there are no layers in this region even if the
+         * background is covering the whole screen
+         */
+        OUTE("hregion %p subregion %d doesn't have any ops", hregion, sidx);
+        return -1;
+    }
+
+    /* Check if the bottom layer is the background */
+    if (hregion->rgz_layers[lix]->hwc_layer == &bg_layer) {
+        if (ldepth == 1) {
+            /* Background layer is the only operation, clear subregion */
+            if (screen_isdirty)
+                rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
+            return 0;
+        } else {
+            /* No need to generate blits with background layer if there is
+             * another layer on top of it, discard it
+             */
+            ldepth--;
+            lix = get_layer_ops_next(hregion, sidx, lix);
+        }
+    }
+
+    /* Determine if this region is dirty */
+    int dirty = 0, dirtylix = lix;
+    while (dirtylix != -1) {
+        rgz_layer_t *rgz_layer = hregion->rgz_layers[dirtylix];
+        if (rgz_layer->dirty_count){
+            /* One of the layers is dirty, we need to generate blits for this subregion */
+            dirty = 1;
+            break;
+        }
+        dirtylix = get_layer_ops_next(hregion, sidx, dirtylix);
+    }
+
+    if (!dirty)
+        return 0;
+
+    if (!noblend && ldepth > 1) { /* BLEND */
+        blit_rect_t *rect = &hregion->blitrects[lix][sidx];
+        struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+
+        int s2lix = lix;
+        lix = get_layer_ops_next(hregion, sidx, lix);
+
+        /*
+         * We save a read and a write from the FB if we blend the bottom
+         * two layers
+         */
+        rgz_src1_prep(e, hregion->rgz_layers[lix], rect, scrdesc, scrgeom, params);
+        rgz_src2blend_prep(e, hregion->rgz_layers[s2lix], rect, params);
+        rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0);
+
+        /* Rest of layers blended with FB */
+        int first = 1;
+        while((lix = get_layer_ops_next(hregion, sidx, lix)) != -1) {
+            int batchflags = 0;
+            e = rgz_blts_get(&blts, params);
+
+            rgz_layer_t *rgz_layer = hregion->rgz_layers[lix];
+            hwc_layer_t *layer = rgz_layer->hwc_layer;
+            rgz_src1_prep(e, rgz_layer, rect, scrdesc, scrgeom, params);
+            rgz_src2blend_prep2(e, layer->transform, rect, scrdesc, scrgeom, 1);
+
+            if (first) {
+                first = 0;
+                batchflags |= BVBATCH_DST | BVBATCH_SRC2 | \
+                              BVBATCH_SRC2RECT_ORIGIN | BVBATCH_SRC2RECT_SIZE;
+            }
+            batchflags |= BVBATCH_SRC1;
+            if (rgz_hwc_scaled(layer))
+                batchflags |= BVBATCH_SRC1RECT_ORIGIN | BVBATCH_SRC1RECT_SIZE;
+            rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags);
+        }
+
+        if (e->bp.flags & BVFLAG_BATCH_BEGIN)
+            rgz_batch_entry(e, 0, 0);
+        else
+            rgz_batch_entry(e, BVFLAG_BATCH_END, 0);
+
+    } else { /* COPY */
+        blit_rect_t *rect = &hregion->blitrects[lix][sidx];
+        if (noblend)    /* get_layer_ops() doesn't understand this so get the top */
+            lix = get_top_rect(hregion, sidx, &rect);
+
+        struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+
+        rgz_layer_t *rgz_layer = hregion->rgz_layers[lix];
+        hwc_layer_t *l = rgz_layer->hwc_layer;
+        rgz_src1_prep(e, rgz_layer, rect, scrdesc, scrgeom, params);
+
+        struct bvsurfgeom *src1geom = &e->src1geom;
+        unsigned long bpflags = BVFLAG_CLIP | BVFLAG_ROP;
+        e->bp.op.rop = 0xCCCC; /* SRCCOPY */
+        if((src1geom->format == OCDFMT_BGR124) ||
+           (src1geom->format == OCDFMT_RGB124) ||
+           (src1geom->format == OCDFMT_RGB16))
+            e->dstgeom.format = OCDFMT_BGR124;
+
+        if (l->transform & HWC_TRANSFORM_FLIP_H)
+            bpflags |= BVFLAG_HORZ_FLIP_SRC1;
+        if (l->transform & HWC_TRANSFORM_FLIP_V)
+            bpflags |= BVFLAG_VERT_FLIP_SRC1;
+        e->bp.flags = bpflags;
+    }
+    return 0;
+}
+
+struct bvbuffdesc gscrndesc = {
+    .structsize = sizeof(struct bvbuffdesc), .length = 0,
+    .auxptr = MAP_FAILED
+};
+struct bvsurfgeom gscrngeom = {
+    .structsize = sizeof(struct bvsurfgeom), .format = OCDFMT_UNKNOWN
+};
+
+static void rgz_blts_init(struct rgz_blts *blts)
+{
+    bzero(blts, sizeof(*blts));
+}
+
+static void rgz_blts_free(struct rgz_blts *blts)
+{
+    /* TODO ??? maybe we should dynamically allocate this */
+    rgz_blts_init(blts);
+}
+
+static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params)
+{
+    struct rgz_blt_entry *ne;
+    if (blts->idx < RGZ_MAX_BLITS) {
+        ne = &blts->bvcmds[blts->idx++];
+        if (IS_BVCMD(params))
+            params->data.bvc.out_blits++;
+    } else {
+        OUTE("!!! BIG PROBLEM !!! run out of blit entries");
+        ne = &blts->bvcmds[blts->idx - 1]; /* Return last slot */
+    }
+    return ne;
+}
+
+static int rgz_blts_bvdirect(rgz_t *rgz, struct rgz_blts *blts, rgz_out_params_t *params)
+{
+    struct bvbatch *batch = NULL;
+    int rv = -1;
+    int idx = 0;
+
+    while (idx < blts->idx) {
+        struct rgz_blt_entry *e = &blts->bvcmds[idx];
+        if (e->bp.flags & BVFLAG_BATCH_MASK)
+            e->bp.batch = batch;
+        rv = bv_blt(&e->bp);
+        if (rv) {
+            OUTE("BV_BLT failed: %d", rv);
+            BVDUMP("bv_blt:", "  ", &e->bp);
+            return -1;
+        }
+        if (e->bp.flags & BVFLAG_BATCH_BEGIN)
+            batch = e->bp.batch;
+        idx++;
+    }
+    return rv;
+}
+
+static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
+{
+    if (!(rgz->state & RGZ_REGION_DATA)) {
+        OUTE("rgz_out_region invoked with bad state");
+        return -1;
+    }
+
+    rgz_blts_init(&blts);
+    ALOGD_IF(debug, "rgz_out_region:");
+
+    if (IS_BVCMD(params))
+        params->data.bvc.out_blits = 0;
+
+    int i;
+    for (i = 0; i < rgz->nhregions; i++) {
+        blit_hregion_t *hregion = &rgz->hregions[i];
+        int s;
+        ALOGD_IF(debug, "h[%d] nsubregions = %d", i, hregion->nsubregions);
+        if (hregion->nlayers == 0) {
+            /* Impossible, there are no layers in this region even if the
+             * background is covering the whole screen
+             */
+            OUTE("hregion %p doesn't have any ops", hregion);
+            return -1;
+        }
+        for (s = 0; s < hregion->nsubregions; s++) {
+            ALOGD_IF(debug, "h[%d] -> [%d]", i, s);
+            rgz_hwc_subregion_blit(hregion, s, params, rgz->screen_isdirty);
+        }
+    }
+
+    int rv = 0;
+
+    if (IS_BVCMD(params)) {
+        unsigned int j;
+        params->data.bvc.out_nhndls = 0;
+        /* Begin from index 1 to remove the background layer from the output */
+        for (j = 1; j < rgz->rgz_layerno; j++) {
+            hwc_layer_t *layer = rgz->rgz_layers[j].hwc_layer;
+            params->data.bvc.out_hndls[j-1] = layer->handle;
+            params->data.bvc.out_nhndls++;
+        }
+
+        /* FIXME: we want to be able to call rgz_blts_free and populate the actual
+         * composition data structure ourselves */
+        params->data.bvc.cmdp = blts.bvcmds;
+        params->data.bvc.cmdlen = blts.idx;
+        if (params->data.bvc.out_blits >= RGZ_MAX_BLITS)
+            rv = -1;
+        //rgz_blts_free(&blts);
+    } else {
+        rv = rgz_blts_bvdirect(rgz, &blts, params);
+        rgz_blts_free(&blts);
+    }
+
+    return rv;
+}
+
+void rgz_profile_hwc(hwc_layer_list_t* list, int dispw, int disph)
+{
+    if (!list)  /* A NULL composition list can occur */
+        return;
+
+#ifndef RGZ_TEST_INTEGRATION
+    static char regiondump2[PROPERTY_VALUE_MAX] = "";
+    char regiondump[PROPERTY_VALUE_MAX];
+    property_get("debug.2dhwc.region", regiondump, "0");
+    int dumpregions = strncmp(regiondump, regiondump2, PROPERTY_VALUE_MAX);
+    if (dumpregions)
+        strncpy(regiondump2, regiondump, PROPERTY_VALUE_MAX);
+    else {
+        dumpregions = !strncmp(regiondump, "all", PROPERTY_VALUE_MAX) &&
+                      (list->flags & HWC_GEOMETRY_CHANGED);
+        static int iteration = 0;
+        if (dumpregions)
+            sprintf(regiondump, "iteration %d", iteration++);
+    }
+
+    char dumplayerdata[PROPERTY_VALUE_MAX];
+    /* 0 - off, 1 - human readable, 2 - CSV */
+    property_get("debug.2dhwc.dumplayers", dumplayerdata, "0");
+    int dumplayers = atoi(dumplayerdata);
+#else
+    char regiondump[] = "";
+    int dumplayers = 1;
+    int dumpregions = 0;
+#endif
+    if (dumplayers && (list->flags & HWC_GEOMETRY_CHANGED)) {
+        OUTP("<!-- BEGUN-LAYER-DUMP: %d -->", list->numHwLayers);
+        rgz_print_layers(list, dumplayers == 1 ? 0 : 1);
+        OUTP("<!-- ENDED-LAYER-DUMP -->");
+    }
+
+    if(!dumpregions)
+        return;
+
+    rgz_t rgz;
+    rgz_in_params_t ip = { .data = { .hwc = {
+                           .layers = list->hwLayers,
+                           .layerno = list->numHwLayers } } };
+    ip.op = RGZ_IN_HWCCHK;
+    if (rgz_in(&ip, &rgz) == RGZ_ALL) {
+        ip.op = RGZ_IN_HWC;
+        if (rgz_in(&ip, &rgz) == RGZ_ALL) {
+            OUTP("<!-- BEGUN-SVG-DUMP: %s -->", regiondump);
+            OUTP("<b>%s</b>", regiondump);
+            rgz_out_params_t op = {
+                .op = RGZ_OUT_SVG,
+                .data = {
+                    .svg = {
+                        .dispw = dispw, .disph = disph,
+                        .htmlw = 450, .htmlh = 800
+                    }
+                },
+            };
+            rgz_out(&rgz, &op);
+            OUTP("<!-- ENDED-SVG-DUMP -->");
+        }
+    }
+    rgz_release(&rgz);
+}
+
+int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt)
+{
+    /* Populate Bltsville destination buffer information with framebuffer data */
+    struct fb_fix_screeninfo fb_fixinfo;
+    struct fb_var_screeninfo fb_varinfo;
+
+    ALOGI("Attempting to get framebuffer device info.");
+    if(ioctl(fd, FBIOGET_FSCREENINFO, &fb_fixinfo)) {
+        OUTE("Error getting fb_fixinfo");
+        return -EINVAL;
+    }
+
+    if(ioctl(fd, FBIOGET_VSCREENINFO, &fb_varinfo)) {
+        ALOGE("Error gettting fb_varinfo");
+        return -EINVAL;
+    }
+
+    bg_layer.displayFrame.left = bg_layer.displayFrame.top = 0;
+    bg_layer.displayFrame.right = fb_varinfo.xres;
+    bg_layer.displayFrame.bottom = fb_varinfo.yres;
+
+    bzero(geom, sizeof(*geom));
+    geom->structsize = sizeof(*geom);
+    geom->width = fb_varinfo.xres;
+    geom->height = fb_varinfo.yres;
+    geom->virtstride = fb_fixinfo.line_length;
+    geom->format = hal_to_ocd(fmt);
+    geom->orientation = 0;
+    return 0;
+}
+
+int rgz_in(rgz_in_params_t *p, rgz_t *rgz)
+{
+    int rv = -1;
+    switch (p->op) {
+    case RGZ_IN_HWC:
+        rv = rgz_in_hwccheck(p, rgz);
+        if (rv == RGZ_ALL)
+            rv = rgz_in_hwc(p, rgz) ? 0 : RGZ_ALL;
+        break;
+    case RGZ_IN_HWCCHK:
+        bzero(rgz, sizeof(rgz_t));
+        rv = rgz_in_hwccheck(p, rgz);
+        break;
+    default:
+        return -1;
+    }
+    return rv;
+}
+
+void rgz_release(rgz_t *rgz)
+{
+    if (!rgz)
+        return;
+    if (rgz->hregions)
+        free(rgz->hregions);
+    bzero(rgz, sizeof(*rgz));
+}
+
+int rgz_out(rgz_t *rgz, rgz_out_params_t *params)
+{
+    switch (params->op) {
+    case RGZ_OUT_SVG:
+        rgz_out_svg(rgz, params);
+        return 0;
+    case RGZ_OUT_BVDIRECT_PAINT:
+        return rgz_out_bvdirect_paint(rgz, params);
+    case RGZ_OUT_BVCMD_PAINT:
+        return rgz_out_bvcmd_paint(rgz, params);
+    case RGZ_OUT_BVDIRECT_REGION:
+    case RGZ_OUT_BVCMD_REGION:
+        return rgz_out_region(rgz, params);
+    default:
+        return -1;
+    }
+}
+
-- 
cgit v1.2.3


From 7cc2b1a368426ac79eac71d625e08324d83a933f Mon Sep 17 00:00:00 2001
From: Craig Stout <craig.stout@ti.com>
Date: Mon, 11 Jun 2012 12:55:19 -0700
Subject: hwc: pass nv12 surfaces to gc320

Rebased from p-ics-mr1:
e2479b9 hwc: pass nv12 surfaces to gc320

Change-Id: I3f161273aa40da2ced869b7b60f2e9fe76cac3bf
Signed-off-by: Craig Stout <craig.stout@ti.com>
(cherry picked from commit ca5f8d664221423dd005f9333adf530aac51bc75)
---
 hwc/rgz_2d.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 7f95a78..7bdaaf1 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -542,9 +542,12 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     if ((layer->flags & HWC_SKIP_LAYER) || !handle)
         return 0;
 
-    if (is_NV12(handle->iFormat) || layer->transform || rgz_hwc_scaled(layer))
+    if (layer->transform || rgz_hwc_scaled(layer))
         return 0;
 
+    if (is_NV12(handle->iFormat))
+        return (handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12);
+
     switch(handle->iFormat) {
     case HAL_PIXEL_FORMAT_BGRX_8888:
     case HAL_PIXEL_FORMAT_RGBX_8888:
-- 
cgit v1.2.3


From cec3d5b8ffff42c2dc5746575172e976feca3450 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 13 Jul 2012 14:26:52 -0500
Subject: hwc: rgz: support layers with the HWC_HINT_CLEAR_FB hint

Allow the regionizer to ignore (and clear if needed) a region
with a layer requesting to clear the framebuffer with a hint.
This mimics what SurfaceFlinger does when the HWC requests to
clear a layer area with transparent pixels.

Rebased from p-ics-mr1:
3c9a753 hwc: rgz: support layers with the HWC_HINT_CLEAR_FB hint

Change-Id: If61a4f50d0315eb23119d7b97b0f2cb5f994806f
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 60d9c93b53b7133aca51d7a125f5d14666a772fe)
---
 hwc/rgz_2d.c | 66 +++++++++++++++++++++++++++++++++++++++++++++++++++++-------
 1 file changed, 59 insertions(+), 7 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 7bdaaf1..3814118 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -346,14 +346,30 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
     rgz_blts_init(&blts);
     rgz_out_clrdst(params, NULL);
 
-    unsigned int i;
+    unsigned int i, j;
 
     /* Begin from index 1 to remove the background layer from the output */
-    for (i = 1; i < rgz->rgz_layerno; i++) {
-        hwc_layer_t *l = rgz->rgz_layers[i].hwc_layer;
+    for (i = 1, j = 0; i < rgz->rgz_layerno; i++) {
+        rgz_layer_t *rgz_layer = &rgz->rgz_layers[i];
+        hwc_layer_t *l = rgz_layer->hwc_layer;
 
         //OUTP("blitting meminfo %d", rgz->rgz_layers[i].buffidx);
 
+        /*
+         * See if it is needed to put transparent pixels where this layer
+         * is located in the screen
+         */
+        if (rgz_layer->buffidx == -1) {
+            struct bvsurfgeom *scrgeom = params->data.bvc.dstgeom;
+            blit_rect_t srcregion;
+            srcregion.left = max(0, l->displayFrame.left);
+            srcregion.top = max(0, l->displayFrame.top);
+            srcregion.bottom = min(scrgeom->height, l->displayFrame.bottom);
+            srcregion.right = min(scrgeom->width, l->displayFrame.right);
+            rgz_out_clrdst(params, &srcregion);
+            continue;
+        }
+
         rv = rgz_hwc_layer_blit(l, params, rgz->rgz_layers[i].buffidx);
         if (rv) {
             OUTE("bvcmd_paint: error in layer %d: %d", i, rv);
@@ -361,7 +377,7 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
             rgz_blts_free(&blts);
             return rv;
         }
-        params->data.bvc.out_hndls[i-1] = l->handle;
+        params->data.bvc.out_hndls[j++] = l->handle;
         params->data.bvc.out_nhndls++;
     }
 
@@ -608,6 +624,23 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
                 }
                 possible_blit++;
             }
+            continue;
+        }
+
+        if (layers[l].hints & HWC_HINT_CLEAR_FB) {
+            candidates++;
+            if (possible_blit < RGZ_INPUT_MAXLAYERS) {
+                /*
+                 * Use only the layer rectangle as an input to regionize when the clear
+                 * fb hint is present, mark this layer to identify it.
+                 */
+                rgz_layer_t *rgz_layer = &rgz->rgz_layers[possible_blit+1];
+                rgz_layer->buffidx = -1;
+                rgz_layer->dirty_count = 0;
+                rgz_layer->dirty_hndl = NULL;
+                rgz_layer->hwc_layer = &layers[l];
+                possible_blit++;
+            }
         }
     }
 
@@ -1189,6 +1222,20 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         }
     }
 
+    /*
+     * See if the depth most layer needs to be ignored. If this layer is the
+     * only operation, we need to clear this subregion.
+     */
+    if (hregion->rgz_layers[lix]->buffidx == -1) {
+        ldepth--;
+        if (!ldepth) {
+            if (screen_isdirty)
+                rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
+            return 0;
+        }
+        lix = get_layer_ops_next(hregion, sidx, lix);
+    }
+
     /* Determine if this region is dirty */
     int dirty = 0, dirtylix = lix;
     while (dirtylix != -1) {
@@ -1367,9 +1414,13 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
         unsigned int j;
         params->data.bvc.out_nhndls = 0;
         /* Begin from index 1 to remove the background layer from the output */
-        for (j = 1; j < rgz->rgz_layerno; j++) {
-            hwc_layer_t *layer = rgz->rgz_layers[j].hwc_layer;
-            params->data.bvc.out_hndls[j-1] = layer->handle;
+        for (j = 1, i = 0; j < rgz->rgz_layerno; j++) {
+            rgz_layer_t *rgz_layer = &rgz->rgz_layers[j];
+            /* We don't need the handles for layers marked as -1 */
+            if (rgz_layer->buffidx == -1)
+                continue;
+            hwc_layer_t *layer = rgz_layer->hwc_layer;
+            params->data.bvc.out_hndls[i++] = layer->handle;
             params->data.bvc.out_nhndls++;
         }
 
@@ -1469,6 +1520,7 @@ int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt)
         return -EINVAL;
     }
 
+    bzero(&bg_layer, sizeof(bg_layer));
     bg_layer.displayFrame.left = bg_layer.displayFrame.top = 0;
     bg_layer.displayFrame.right = fb_varinfo.xres;
     bg_layer.displayFrame.bottom = fb_varinfo.yres;
-- 
cgit v1.2.3


From 8438ab1da64c136916ecf1dfe07869cfa688c8be Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Mon, 18 Jun 2012 17:22:45 -0500
Subject: hwc: regionizer: Batch flags fixes

+ Removed BVBATCH_DST since the destination parameters (buffdesc
  and geometry) are not changing while performing blending within
  a batch.
+ Removed BVBATCH_SRC2RECT_SIZE, the rectangle size never changes
  while constructing blits within a horizontal subregion.
+ Added BVBATCH_SRC1RECT_ORIGIN, it's highly possible the src1 origin
  changes from a previous blit within the batch, a good example is the
  volume pop blended on top of the widget and wallpaper layers in the
  Android homescreen.

This change doesn't address batch flags while scaling, those will
be revisited later when the GC driver supports it.

Rebased from p-ics-mr1 (also cleaned up commit msg):
93b69ce hwc: regionizer: Batch flags fixes

Change-Id: I9b85dce832b391e347aab93800e0b22e67072227
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 29136475929f69250818d96cf106d28ed4e1cd80)
---
 hwc/rgz_2d.c | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 3814118..7717599 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -1279,10 +1279,9 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
 
             if (first) {
                 first = 0;
-                batchflags |= BVBATCH_DST | BVBATCH_SRC2 | \
-                              BVBATCH_SRC2RECT_ORIGIN | BVBATCH_SRC2RECT_SIZE;
+                batchflags |= BVBATCH_SRC2 | BVBATCH_SRC2RECT_ORIGIN;
             }
-            batchflags |= BVBATCH_SRC1;
+            batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN;
             if (rgz_hwc_scaled(layer))
                 batchflags |= BVBATCH_SRC1RECT_ORIGIN | BVBATCH_SRC1RECT_SIZE;
             rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags);
-- 
cgit v1.2.3


From e90714f1863dc151fb2bb7374c0c7ed0b7d75a14 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Tue, 12 Jun 2012 16:20:26 -0500
Subject: hwc: regionizer: Add asynchronous blits support

Regionizer adds the BVFLAG_ASYNC to all the blits, except for the
last one which is made synchronous. The last blit acts like a
fence to let the previous asynchronous blits to finish first.

Support in the GC driver must be present for this feature to work
properly.

Rebased from p-ics-mr1:
822ec12 hwc: regionizer: Add asynchronous blits support

Change-Id: Iec32de51e7d0b95d1b780e60ed4848e8daf7977f
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 75bcf14b2937c1edbe83834ae93371995dd64b0f)
---
 hwc/rgz_2d.c | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 7717599..b87478f 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -287,6 +287,11 @@ static int rgz_out_bvdirect_paint(rgz_t *rgz, rgz_out_params_t *params)
     return rv;
 }
 
+static void rgz_set_async(struct rgz_blt_entry *e, int async)
+{
+    e->bp.flags = async ? e->bp.flags | BVFLAG_ASYNC : e->bp.flags & ~BVFLAG_ASYNC;
+}
+
 /*
  * Clear the destination buffer, if rect is NULL means the whole screen, rect
  * cannot be outside the boundaries of the screen
@@ -336,6 +341,7 @@ static void rgz_out_clrdst(rgz_out_params_t *params, blit_rect_t *rect)
 
     bp->flags = BVFLAG_CLIP | BVFLAG_ROP;
     bp->op.rop = 0xCCCC; /* SRCCOPY */
+    rgz_set_async(e, 1);
 }
 
 static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
@@ -381,6 +387,10 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
         params->data.bvc.out_nhndls++;
     }
 
+    /* Last blit is made sync to act like a fence for the previous async blits */
+    struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1];
+    rgz_set_async(e, 0);
+
     /* FIXME: we want to be able to call rgz_blts_free and populate the actual
      * composition data structure ourselves */
     params->data.bvc.cmdp = blts.bvcmds;
@@ -1022,6 +1032,7 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
         bpflags |= BVFLAG_VERT_FLIP_SRC1;
 
     bp->flags = bpflags;
+    rgz_set_async(e, 1);
 
     return 0;
 }
@@ -1265,6 +1276,7 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         rgz_src1_prep(e, hregion->rgz_layers[lix], rect, scrdesc, scrgeom, params);
         rgz_src2blend_prep(e, hregion->rgz_layers[s2lix], rect, params);
         rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0);
+        rgz_set_async(e, 1);
 
         /* Rest of layers blended with FB */
         int first = 1;
@@ -1285,6 +1297,7 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
             if (rgz_hwc_scaled(layer))
                 batchflags |= BVBATCH_SRC1RECT_ORIGIN | BVBATCH_SRC1RECT_SIZE;
             rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags);
+            rgz_set_async(e, 1);
         }
 
         if (e->bp.flags & BVFLAG_BATCH_BEGIN)
@@ -1316,6 +1329,7 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         if (l->transform & HWC_TRANSFORM_FLIP_V)
             bpflags |= BVFLAG_VERT_FLIP_SRC1;
         e->bp.flags = bpflags;
+        rgz_set_async(e, 1);
     }
     return 0;
 }
@@ -1423,6 +1437,10 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
             params->data.bvc.out_nhndls++;
         }
 
+        /* Last blit is made sync to act like a fence for the previous async blits */
+        struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1];
+        rgz_set_async(e, 0);
+
         /* FIXME: we want to be able to call rgz_blts_free and populate the actual
          * composition data structure ourselves */
         params->data.bvc.cmdp = blts.bvcmds;
-- 
cgit v1.2.3


From db987b5b5c7421a5f3de3ba284e1efa015351712 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Wed, 13 Jun 2012 15:28:13 -0500
Subject: hwc: regionizer: Give support for rotation with Bltsville

Enables the regionizer to support rotation with Bltsville.
This patch doesn't enable horizontal/vertical flips yet.

Rebased from p-ics-mr1:
bd6d0b5 hwc: regionizer: Give support for rotation with Bltsville

Change-Id: I595debea076727ef2c442d7544c1e355aef04808
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
Signed-off-by: Tony Lofthouse <a0741364@ti.com>
(cherry picked from commit eb5940af48a3b9bd029a5c70d7838d89a03c302b)
---
 hwc/rgz_2d.c | 212 +++++++++++++++++++++++++++++++++++++++--------------------
 1 file changed, 141 insertions(+), 71 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index b87478f..8aa0866 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -100,6 +100,7 @@ static void rgz_blts_init(struct rgz_blts *blts);
 static void rgz_blts_free(struct rgz_blts *blts);
 static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params);
 static int rgz_blts_bvdirect(rgz_t* rgz, struct rgz_blts *blts, rgz_out_params_t *params);
+static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect);
 
 int debug = 0;
 struct rgz_blts blts;
@@ -568,12 +569,24 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     if ((layer->flags & HWC_SKIP_LAYER) || !handle)
         return 0;
 
-    if (layer->transform || rgz_hwc_scaled(layer))
+    if (rgz_hwc_scaled(layer))
         return 0;
 
     if (is_NV12(handle->iFormat))
         return (handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12);
 
+    /* FIXME: The following must be removed when GC supports vertical/horizontal
+     * buffer flips, please note having a FLIP_H and FLIP_V means 180 rotation
+     * which is supported indeed
+     */
+    if (layer->transform) {
+        int is_flipped = !!(layer->transform & HWC_TRANSFORM_FLIP_H) ^ !!(layer->transform & HWC_TRANSFORM_FLIP_V);
+        if (is_flipped) {
+            ALOGE("Layer %p is flipped %d", layer, layer->transform);
+            return 0;
+        }
+    }
+
     switch(handle->iFormat) {
     case HAL_PIXEL_FORMAT_BGRX_8888:
     case HAL_PIXEL_FORMAT_RGBX_8888:
@@ -924,6 +937,31 @@ static int rgz_handle_to_stride(IMG_native_handle_t *h)
 
 extern void BVDump(const char* prefix, const char* tab, const struct bvbltparams* parms);
 
+static int rgz_get_orientation(unsigned int transform)
+{
+    int orientation = 0;
+    if ((transform & HWC_TRANSFORM_FLIP_H) && (transform & HWC_TRANSFORM_FLIP_V))
+        orientation += 180;
+    if (transform & HWC_TRANSFORM_ROT_90)
+        orientation += 90;
+
+    return orientation;
+}
+
+static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags)
+{
+    /*
+     * If vertical and horizontal flip flags are set it means a 180 rotation
+     * (with no flip) is intended for the layer, so we return 0 in that case.
+     */
+    int flip_flags = 0;
+    if (transform & HWC_TRANSFORM_FLIP_H)
+        flip_flags |= (use_src2_flags ? BVFLAG_HORZ_FLIP_SRC2 : BVFLAG_HORZ_FLIP_SRC1);
+    if (transform & HWC_TRANSFORM_FLIP_V)
+        flip_flags = flip_flags ? 0 : flip_flags | (use_src2_flags ? BVFLAG_VERT_FLIP_SRC2 : BVFLAG_VERT_FLIP_SRC1);
+    return flip_flags;
+}
+
 static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff_idx)
 {
     IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
@@ -970,9 +1008,9 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
     src1geom->format = hal_to_ocd(handle->iFormat);
     src1geom->width = handle->iWidth;
     src1geom->height = handle->iHeight;
-    src1geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
-            l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
-            l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
+    if (l->transform & HAL_TRANSFORM_ROT_90)
+        swap(src1geom->width, src1geom->height);
+    src1geom->orientation = rgz_get_orientation(l->transform);
     src1geom->virtstride = HANDLE_TO_STRIDE(handle);
 
     struct bvsurfgeom *dstgeom = &e->dstgeom;
@@ -980,7 +1018,8 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
     dstgeom->format = scrgeom->format;
     dstgeom->width = scrgeom->width;
     dstgeom->height = scrgeom->height;
-    dstgeom->orientation = 0; /* TODO */
+    /* Destination always set to 0, src buffers will contain rotation values as needed */
+    dstgeom->orientation = 0;
     dstgeom->virtstride = DSTSTRIDE(scrgeom);
 
     struct bvbltparams *bp = &e->bp;
@@ -993,14 +1032,22 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
     bp->dstrect.height = HEIGHT(l->displayFrame);
     bp->src1.desc = src1desc;
     bp->src1geom = src1geom;
-    bp->src1rect.left = l->sourceCrop.left;
-    bp->src1rect.top = l->sourceCrop.top;
-    bp->src1rect.width = WIDTH(l->sourceCrop);
-    bp->src1rect.height = HEIGHT(l->sourceCrop);
     bp->cliprect.left = bp->cliprect.top = 0;
     bp->cliprect.width = scrgeom->width;
     bp->cliprect.height = scrgeom->height;
 
+    blit_rect_t src1rect;
+    blit_rect_t src1region;
+    src1region.left = l->displayFrame.left;
+    src1region.top = l->displayFrame.top;
+    src1region.bottom = l->displayFrame.bottom;
+    src1region.right = l->displayFrame.right;
+    rgz_get_src_rect(l, &src1region, &src1rect);
+    bp->src1rect.left = src1rect.left;
+    bp->src1rect.top = src1rect.top;
+    bp->src1rect.width = WIDTH(src1rect);
+    bp->src1rect.height = HEIGHT(src1rect);
+
     unsigned long bpflags = BVFLAG_CLIP;
     if (!noblend && l->blending == HWC_BLENDING_PREMULT) {
         struct bvsurfgeom *src2geom = &e->src2geom;
@@ -1025,12 +1072,7 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
             dstgeom->format = OCDFMT_BGR124;
     }
 
-    /* TODO regionizer won't permit transforms yet */
-    if (l->transform & HWC_TRANSFORM_FLIP_H)
-        bpflags |= BVFLAG_HORZ_FLIP_SRC1;
-    if (l->transform & HWC_TRANSFORM_FLIP_V)
-        bpflags |= BVFLAG_VERT_FLIP_SRC1;
-
+    bpflags |= rgz_get_flip_flags(l->transform, 0);
     bp->flags = bpflags;
     rgz_set_async(e, 1);
 
@@ -1038,23 +1080,55 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
 }
 
 /*
- * Calculate the left coord of the source on the basis of the location of the
- * blit subregion relative to the HWC layer display frame
+ * Calculate the src rectangle on the basis of the layer display, source crop
+ * and subregion rectangles. Additionally any rotation will be taken in
+ * account. The resulting rectangle is written in res_rect.
+ * Note: This doesn't work if the layer is scaled, another approach must be
+ * taken in this situation.
  */
-static int effective_srcleft(hwc_layer_t* l, blit_rect_t *rect)
+static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect)
 {
-    // Assert rect->left >= l->sourceCrop.left
-    // Assert rect->left < l->sourceCrop.left + WIDTH(l->sourceCrop)
-    return l->sourceCrop.left + ((WIDTH(l->sourceCrop) * (rect->left - l->displayFrame.left)) / WIDTH(l->displayFrame));
-}
+    if (rgz_hwc_scaled(layer))
+        ALOGE("%s: layer %p is scaled", __func__, layer);
 
-static int effective_srctop(hwc_layer_t* l, blit_rect_t *rect)
-{
-    // Assert rect->top >= l->sourceCrop.top
-    // Assert rect->top < l->sourceCrop.top + HEIGHT(l->sourceCrop)
-    return l->sourceCrop.top + ((HEIGHT(l->sourceCrop) * (rect->top - l->displayFrame.top)) / HEIGHT(l->displayFrame));
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+    int res_left = 0;
+    int res_top = 0;
+    int delta_left = subregion_rect->left - layer->displayFrame.left;
+    int delta_top = subregion_rect->top - layer->displayFrame.top;
+    /*
+     * Calculate the top, left offset from the source cropping rectangle
+     * depending on the rotation
+     */
+    switch(layer->transform) {
+        case 0:
+            res_left = layer->sourceCrop.left + delta_left;
+            res_top = layer->sourceCrop.top + delta_top;
+            break;
+        case HAL_TRANSFORM_ROT_90:
+            res_left = handle->iHeight - layer->sourceCrop.bottom + delta_left;
+            res_top = layer->sourceCrop.left + delta_top;
+            break;
+        case HAL_TRANSFORM_ROT_180:
+            res_left = handle->iWidth - layer->sourceCrop.right + delta_left;
+            res_top = handle->iHeight - layer->sourceCrop.bottom + delta_top;
+            break;
+        case HAL_TRANSFORM_ROT_270:
+            res_left = layer->sourceCrop.top + delta_left;
+            res_top = handle->iWidth - layer->sourceCrop.right + delta_top;
+            break;
+        default:
+            OUTE("Invalid transform value %d", layer->transform);
+    }
+
+    /* Resulting rectangle has the subregion dimensions */
+    res_rect->left = res_left;
+    res_rect->top = res_top;
+    res_rect->right = res_left + WIDTH(*subregion_rect);
+    res_rect->bottom = res_top + HEIGHT(*subregion_rect);
 }
 
+
 /*
  * Setup the src2 rectangle and the passed descriptor and
  * geometry
@@ -1066,14 +1140,10 @@ static void rgz_src2blend_prep2(
     unsigned long bpflags = BVFLAG_CLIP;
 
     struct bvbltparams *bp = &e->bp;
-    bpflags |= BVFLAG_BLEND; // FIXME batch?
+    bpflags |= BVFLAG_BLEND;
     bp->op.blend = BVBLEND_SRC1OVER;
     bp->src2.desc = dstdesc;
     bp->src2geom = dstgeom;
-    bp->src2rect.left = rect->left;
-    bp->src2rect.top = rect->top;
-    bp->src2rect.width = WIDTH(*rect);
-    bp->src2rect.height = HEIGHT(*rect);
 
     if (is_fb_dest) {
         struct bvsurfgeom *src2geom = &e->src2geom;
@@ -1081,14 +1151,19 @@ static void rgz_src2blend_prep2(
         *src2geom = *dstgeom;
         src2desc->structsize = sizeof(struct bvbuffdesc);
         src2desc->auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
+        /* Destination always set to 0, src buffers will contain rotation values as needed */
+        src2geom->orientation = 0;
+        bp->src2rect.left = rect->left;
+        bp->src2rect.top = rect->top;
+        bp->src2rect.width = WIDTH(*rect);
+        bp->src2rect.height = HEIGHT(*rect);
+    } else {
+        struct bvsurfgeom *src2geom = &e->src2geom;
+        src2geom->orientation = rgz_get_orientation(hwc_transform);
+        bpflags |= rgz_get_flip_flags(hwc_transform, 1);
     }
 
-    if (hwc_transform & HWC_TRANSFORM_FLIP_H)
-        bpflags |= BVFLAG_HORZ_FLIP_SRC1;
-    if (hwc_transform & HWC_TRANSFORM_FLIP_V)
-        bpflags |= BVFLAG_VERT_FLIP_SRC1;
-
-    bp->flags = bpflags;
+    bp->flags |= bpflags;
 }
 
 static void rgz_src2blend_prep(
@@ -1108,22 +1183,19 @@ static void rgz_src2blend_prep(
     src2geom->format = hal_to_ocd(handle->iFormat);
     src2geom->width = handle->iWidth;
     src2geom->height = handle->iHeight;
-    src2geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
-        l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
-        l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
     src2geom->virtstride = HANDLE_TO_STRIDE(handle);
+    if (l->transform & HAL_TRANSFORM_ROT_90)
+        swap(src2geom->width, src2geom->height);
 
-    /*
-     * This looks a little odd but what we need to do here is take the
-     * rectangle which has coordinates in terms of the display dimensions
-     * and find the offset of the source buffer for the layer
-     */
-    blit_rect_t src2rect = *rect;
-    src2rect.top = effective_srctop(l, rect);
-    src2rect.left = effective_srcleft(l, rect);
-    src2rect.bottom = src2rect.top + HEIGHT(*rect);
-    src2rect.right = src2rect.left + WIDTH(*rect);
-    rgz_src2blend_prep2(e, l->transform, &src2rect, src2desc, src2geom, 0);
+    struct bvbltparams *bp = &e->bp;
+    blit_rect_t src2rect;
+    rgz_get_src_rect(l, rect, &src2rect);
+    bp->src2rect.left = src2rect.left;
+    bp->src2rect.top = src2rect.top;
+    bp->src2rect.width = WIDTH(src2rect);
+    bp->src2rect.height = HEIGHT(src2rect);
+
+    rgz_src2blend_prep2(e, l->transform, rect, src2desc, src2geom, 0);
 }
 
 static void rgz_src1_prep(
@@ -1148,16 +1220,17 @@ static void rgz_src1_prep(
     src1geom->format = hal_to_ocd(handle->iFormat);
     src1geom->width = handle->iWidth;
     src1geom->height = handle->iHeight;
-    src1geom->orientation = l->transform & HWC_TRANSFORM_ROT_90 ? 90 :
-            l->transform & HWC_TRANSFORM_ROT_180 ? 180 :
-            l->transform & HWC_TRANSFORM_ROT_270 ? 270 : 0;
+    src1geom->orientation = rgz_get_orientation(l->transform);
     src1geom->virtstride = HANDLE_TO_STRIDE(handle);
+    if (l->transform & HAL_TRANSFORM_ROT_90)
+        swap(src1geom->width, src1geom->height);
 
     struct bvsurfgeom *dstgeom = &e->dstgeom;
     dstgeom->structsize = sizeof(struct bvsurfgeom);
     dstgeom->format = scrgeom->format;
     dstgeom->width = scrgeom->width;
     dstgeom->height = scrgeom->height;
+    /* Destination always set to 0, src buffers will contain rotation values as needed */
     dstgeom->orientation = 0;
     dstgeom->virtstride = DSTSTRIDE(scrgeom);
 
@@ -1165,19 +1238,20 @@ static void rgz_src1_prep(
     bp->structsize = sizeof(struct bvbltparams);
     bp->dstdesc = scrdesc;
     bp->dstgeom = dstgeom;
-    bp->dstrect.left = rect->left;
-    bp->dstrect.top = rect->top;
-    bp->dstrect.width = WIDTH(*rect);
-    bp->dstrect.height = HEIGHT(*rect);
+    bp->cliprect.left = bp->dstrect.left = rect->left;
+    bp->cliprect.top = bp->dstrect.top = rect->top;
+    bp->cliprect.width = bp->dstrect.width = WIDTH(*rect);
+    bp->cliprect.height = bp->dstrect.height = HEIGHT(*rect);
     bp->src1.desc = src1desc;
     bp->src1geom = src1geom;
-    bp->src1rect.left = effective_srcleft(l, rect);
-    bp->src1rect.top = effective_srctop(l, rect);
-    bp->src1rect.width = WIDTH(*rect); // XXX fixme - effective width/height?
-    bp->src1rect.height = HEIGHT(*rect);
-    bp->cliprect.left = bp->cliprect.top = 0;
-    bp->cliprect.width = scrgeom->width;
-    bp->cliprect.height = scrgeom->height;
+
+    blit_rect_t src1rect;
+    rgz_get_src_rect(l, rect, &src1rect);
+    bp->src1rect.left = src1rect.left;
+    bp->src1rect.top = src1rect.top;
+    bp->src1rect.width = WIDTH(src1rect);
+    bp->src1rect.height = HEIGHT(src1rect);
+    bp->flags |= rgz_get_flip_flags(l->transform, 0);
 }
 
 static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned int set)
@@ -1324,12 +1398,8 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
            (src1geom->format == OCDFMT_RGB16))
             e->dstgeom.format = OCDFMT_BGR124;
 
-        if (l->transform & HWC_TRANSFORM_FLIP_H)
-            bpflags |= BVFLAG_HORZ_FLIP_SRC1;
-        if (l->transform & HWC_TRANSFORM_FLIP_V)
-            bpflags |= BVFLAG_VERT_FLIP_SRC1;
-        e->bp.flags = bpflags;
         rgz_set_async(e, 1);
+        e->bp.flags |= bpflags;
     }
     return 0;
 }
-- 
cgit v1.2.3


From 7a24cc1dc70da3dc57a98895010974746dafe78e Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 13 Jul 2012 15:22:22 -0500
Subject: hwc: rgz: Disable NV12 rotation support for the regionizer

There is a bug when rotating NV12 buffers with the GC driver,
disable this for now until it is fixed.

Rebased from p-ics-mr1:
7c46d80 hwc: rgz: Disable NV12 rotation support for the regionizer

Change-Id: Ia3add3266bd308fec34cb2b9140146d1da07f7ec
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 86e65069ed99621c0b9d6c46096bb0bf2fbe97ef)
---
 hwc/rgz_2d.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 8aa0866..444db7f 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -573,7 +573,7 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
         return 0;
 
     if (is_NV12(handle->iFormat))
-        return (handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12);
+        return (!layer->transform && handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12);
 
     /* FIXME: The following must be removed when GC supports vertical/horizontal
      * buffer flips, please note having a FLIP_H and FLIP_V means 180 rotation
-- 
cgit v1.2.3


From ad1bb2394c720bb4b9e794ceffb7e8d271bf3b25 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Mon, 16 Jul 2012 10:27:22 -0500
Subject: hwc: rgz: Workaround for hdmi hotplug crash with 2D blitter enabled

When the hdmi cable is connected a hotplug event is triggered, this
forces the DSS to exhaust the pipes available in most situations
so the 2D blitter is used to handle some layers.

When the cable is connected/disconnected it's highly possible a
geometry change doesn't happen right away (or it may not happen)
leading the region data to be invalid and not recalculated for an
instant, this ends up in sending to the blitter incorrect src
rectangle origins and sizes, most of the time this leads to L3
errors making the system unstable and unable to recover.

Rebased from p-ics-mr1:
104249c hwc: rgz: Workaround for hdmi hotplug crash with 2D blitter enabled

Change-Id: Ie1675d0a0dd03e69fac80dd51cee006fcd6f8791
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit d5907246f792b70e82db195b1c5fb5c1c5be9d5d)
---
 hwc/rgz_2d.c | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 444db7f..9e2dcea 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -689,10 +689,12 @@ static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz)
         return -1;
     }
 
+#if 0
     /* If there is already region data avoid parsing it again */
     if (rgz->state & RGZ_REGION_DATA) {
         return 0;
     }
+#endif
 
     int layerno = rgz->rgz_layerno;
 
@@ -1622,11 +1624,23 @@ int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt)
     return 0;
 }
 
+/* Reset the values needed for every frame, except the dirty region handles */
+static void rgz_reset(rgz_t *rgz){
+    if (!rgz)
+        return;
+    if (rgz->hregions)
+        free(rgz->hregions);
+    rgz->hregions = NULL;
+    rgz->nhregions = 0;
+    rgz->state = 0;
+}
+
 int rgz_in(rgz_in_params_t *p, rgz_t *rgz)
 {
     int rv = -1;
     switch (p->op) {
     case RGZ_IN_HWC:
+        rgz_reset(rgz);
         rv = rgz_in_hwccheck(p, rgz);
         if (rv == RGZ_ALL)
             rv = rgz_in_hwc(p, rgz) ? 0 : RGZ_ALL;
-- 
cgit v1.2.3


From 2c96270e021fa6c5e16dc0f42d81fa231ea40293 Mon Sep 17 00:00:00 2001
From: Tony Lofthouse <a0741364@ti.com>
Date: Fri, 20 Jul 2012 09:50:51 -0500
Subject: hwc: rgz: Fix dirty region not working when blitting only one layer

The dirty region handling doesn't work properly when only one
layer is being blitted. The problem was the screen dirty state was
only set to zero when one layer reaches the dirty count to zero. In
case only one layer was being blitted the dirty region handling
is never triggered making the empty areas to be cleared on every
frame even if it was not needed.

This patch removes the screen dirty flag and instead introduces
a dirty count for the background and layers with the clear fb hint
as well, since we don't care about the handle, the dirty count
is decreased on every frame, in this way the dirty region handling
sees the background and layers with the clear fb hint as any other
layer.

Rebased from p-ics-mr1:
11e5f7e hwc: rgz: Fix dirty region not working when blitting only one layer

Change-Id: Ifbb111ce7738cd097e74ac01e2c48f3994857416
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>

Conflicts:

	hwc/rgz_2d.c

Signed-off-by: Tony Lofthouse <a0741364@ti.com>
(cherry picked from commit a79d46bbd0438140fb6500d6243b5e3aa392068b)
---
 hwc/rgz_2d.c | 71 +++++++++++++++++++++++++++++++++++-------------------------
 1 file changed, 41 insertions(+), 30 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 9e2dcea..abf2722 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -624,10 +624,18 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
     }
 
     int possible_blit = 0, candidates = 0;
-    rgz->screen_isdirty = 1;
 
-    /* Insert the background layer at the beginning of the list */
-    rgz->rgz_layers[0].hwc_layer = &bg_layer;
+    /*
+     * Insert the background layer at the beginning of the list, maintain a
+     * state for dirty region handling
+     */
+    rgz_layer_t *rgz_layer = &rgz->rgz_layers[0];
+    rgz_layer->hwc_layer = &bg_layer;
+    if (!rgz_layer->dirty_hndl) {
+        rgz_layer->dirty_hndl = (void*)0x1;
+        rgz_layer->dirty_count = RGZ_NUM_FB;
+    } else
+        rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
 
     for (l = 0; l < layerno; l++) {
         if (layers[l].compositionType == HWC_FRAMEBUFFER) {
@@ -640,11 +648,9 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
                 if (rgz_layer->hwc_layer->handle != rgz_layer->dirty_hndl) {
                     rgz_layer->dirty_count = RGZ_NUM_FB;
                     rgz_layer->dirty_hndl = (void*)rgz_layer->hwc_layer->handle;
-                } else {
+                } else
                      rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
-                     if (rgz_layer->dirty_count == 0)
-                         rgz->screen_isdirty = 0; /* Just update dirty regions from now on */
-                }
+
                 possible_blit++;
             }
             continue;
@@ -659,9 +665,16 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
                  */
                 rgz_layer_t *rgz_layer = &rgz->rgz_layers[possible_blit+1];
                 rgz_layer->buffidx = -1;
-                rgz_layer->dirty_count = 0;
-                rgz_layer->dirty_hndl = NULL;
                 rgz_layer->hwc_layer = &layers[l];
+                /*
+                 * We don't care about the handle but we want to maintain a layer state for
+                 * dirty region handling
+                 */
+                if (!rgz_layer->dirty_hndl) {
+                    rgz_layer->dirty_hndl = (void*)0x1;
+                    rgz_layer->dirty_count = RGZ_NUM_FB;
+                } else
+                    rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
                 possible_blit++;
             }
         }
@@ -1263,7 +1276,7 @@ static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned
     e->bp.batchflags |= set;
 }
 
-static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_params_t *params, int screen_isdirty)
+static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_params_t *params)
 {
     static int loaded = 0;
     if (!loaded)
@@ -1293,12 +1306,26 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         return -1;
     }
 
+    /* Determine if this region is dirty */
+    int dirty = 0, dirtylix = lix;
+    while (dirtylix != -1) {
+        rgz_layer_t *rgz_layer = hregion->rgz_layers[dirtylix];
+        if (rgz_layer->dirty_count){
+            /* One of the layers is dirty, we need to generate blits for this subregion */
+            dirty = 1;
+            break;
+        }
+        dirtylix = get_layer_ops_next(hregion, sidx, dirtylix);
+    }
+
+    if (!dirty)
+        return 0;
+
     /* Check if the bottom layer is the background */
     if (hregion->rgz_layers[lix]->hwc_layer == &bg_layer) {
         if (ldepth == 1) {
             /* Background layer is the only operation, clear subregion */
-            if (screen_isdirty)
-                rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
+            rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
             return 0;
         } else {
             /* No need to generate blits with background layer if there is
@@ -1316,28 +1343,12 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
     if (hregion->rgz_layers[lix]->buffidx == -1) {
         ldepth--;
         if (!ldepth) {
-            if (screen_isdirty)
-                rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
+            rgz_out_clrdst(params, &hregion->blitrects[lix][sidx]);
             return 0;
         }
         lix = get_layer_ops_next(hregion, sidx, lix);
     }
 
-    /* Determine if this region is dirty */
-    int dirty = 0, dirtylix = lix;
-    while (dirtylix != -1) {
-        rgz_layer_t *rgz_layer = hregion->rgz_layers[dirtylix];
-        if (rgz_layer->dirty_count){
-            /* One of the layers is dirty, we need to generate blits for this subregion */
-            dirty = 1;
-            break;
-        }
-        dirtylix = get_layer_ops_next(hregion, sidx, dirtylix);
-    }
-
-    if (!dirty)
-        return 0;
-
     if (!noblend && ldepth > 1) { /* BLEND */
         blit_rect_t *rect = &hregion->blitrects[lix][sidx];
         struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
@@ -1489,7 +1500,7 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
         }
         for (s = 0; s < hregion->nsubregions; s++) {
             ALOGD_IF(debug, "h[%d] -> [%d]", i, s);
-            rgz_hwc_subregion_blit(hregion, s, params, rgz->screen_isdirty);
+            rgz_hwc_subregion_blit(hregion, s, params);
         }
     }
 
-- 
cgit v1.2.3


From 362d76501749eaa6221ebbb63fcf58542449a391 Mon Sep 17 00:00:00 2001
From: Tony Lofthouse <a0741364@ti.com>
Date: Thu, 26 Jul 2012 13:49:25 -0500
Subject: hwc: rgz: Fix for pixel wide regions returning no ops

A region that is pixel wide is in the top-left corner of the screen
(0,0,1,1) makes the empty_rect function to return true, which
is wrong since the region is not an empty rectangle.

Since this function is being used in the moment the blits are
generated, the regionizer thinks the region is empty with no
intersections leading to error messages.

Change-Id: I5f838008a39dcd469e325cb3fdd834408aa91291
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
Signed-off-by: Tony Lofthouse <a0741364@ti.com>
(cherry picked from commit 7863b0c86de6bae53e2afb4294b32f2f9840f2b8)
---
 hwc/rgz_2d.c | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index abf2722..63dfaf1 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -136,7 +136,7 @@ static void svgout_rect(blit_rect_t *r, char *color, char *text)
 
 static int empty_rect(blit_rect_t *r)
 {
-    return !((((r->left == r->top) == r->right) == r->bottom) == 0);
+    return !r->left && !r->top && !r->right && !r->bottom;
 }
 
 static int get_top_rect(blit_hregion_t *hregion, int subregion, blit_rect_t **routp)
@@ -1500,7 +1500,8 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
         }
         for (s = 0; s < hregion->nsubregions; s++) {
             ALOGD_IF(debug, "h[%d] -> [%d]", i, s);
-            rgz_hwc_subregion_blit(hregion, s, params);
+            if (rgz_hwc_subregion_blit(hregion, s, params))
+                return -1;
         }
     }
 
-- 
cgit v1.2.3


From ec3c877e686bc277a2ba425c2a5e7a73790eb328 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 3 Aug 2012 14:56:33 -0500
Subject: hwc: rgz: Fix invalid dirty region state when HDMI is connected

It is possible when the HDMI cable is plugged in a geometry change
doesn't happen, hence the layers handled by the DSS and the
regionizer differ, since the dirty region counters are only reset
when a geometry change happens, this causes them to enter into
an invalid state leading to visual artifacts.

This fix compares  if at any given time, the layers handled in the
regionizer differ in number from the previous frame, if that happens,
the dirty region counters are reset for all the layers.

Change-Id: If756b526cf52d66612729d7367c26d131c8a1ac0
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit f683df8b15dcc60d497ca1ef9e0bad2bf280fb5b)
---
 hwc/rgz_2d.c | 53 ++++++++++++++++++++++++++++++++---------------------
 1 file changed, 32 insertions(+), 21 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 63dfaf1..33f04b2 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -600,6 +600,32 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     return 1;
 }
 
+static void rgz_handle_dirty_region(rgz_t *rgz, int reset_counters)
+{
+    unsigned int i;
+    for (i = 0; i < rgz->rgz_layerno; i++) {
+        rgz_layer_t *rgz_layer = &rgz->rgz_layers[i];
+        void *new_handle;
+
+        /*
+         * We don't care about the handle for background and layers with the
+         * clear fb hint, but we want to maintain a layer state for dirty
+         * region handling.
+         */
+        if (i == 0 || rgz_layer->buffidx == -1)
+            new_handle = (void*)0x1;
+        else
+            new_handle = (void*)rgz_layer->hwc_layer->handle;
+
+        if (reset_counters || new_handle != rgz_layer->dirty_hndl) {
+            rgz_layer->dirty_count = RGZ_NUM_FB;
+            rgz_layer->dirty_hndl = new_handle;
+        } else
+            rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
+
+    }
+}
+
 static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
 {
     hwc_layer_t *layers = p->data.hwc.layers;
@@ -631,11 +657,6 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
      */
     rgz_layer_t *rgz_layer = &rgz->rgz_layers[0];
     rgz_layer->hwc_layer = &bg_layer;
-    if (!rgz_layer->dirty_hndl) {
-        rgz_layer->dirty_hndl = (void*)0x1;
-        rgz_layer->dirty_count = RGZ_NUM_FB;
-    } else
-        rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
 
     for (l = 0; l < layerno; l++) {
         if (layers[l].compositionType == HWC_FRAMEBUFFER) {
@@ -645,12 +666,6 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
                 rgz_layer_t *rgz_layer = &rgz->rgz_layers[possible_blit+1];
                 rgz_layer->hwc_layer = &layers[l];
                 rgz_layer->buffidx = memidx++;
-                if (rgz_layer->hwc_layer->handle != rgz_layer->dirty_hndl) {
-                    rgz_layer->dirty_count = RGZ_NUM_FB;
-                    rgz_layer->dirty_hndl = (void*)rgz_layer->hwc_layer->handle;
-                } else
-                     rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
-
                 possible_blit++;
             }
             continue;
@@ -666,15 +681,6 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
                 rgz_layer_t *rgz_layer = &rgz->rgz_layers[possible_blit+1];
                 rgz_layer->buffidx = -1;
                 rgz_layer->hwc_layer = &layers[l];
-                /*
-                 * We don't care about the handle but we want to maintain a layer state for
-                 * dirty region handling
-                 */
-                if (!rgz_layer->dirty_hndl) {
-                    rgz_layer->dirty_hndl = (void*)0x1;
-                    rgz_layer->dirty_count = RGZ_NUM_FB;
-                } else
-                    rgz_layer->dirty_count -= rgz_layer->dirty_count ? 1 : 0;
                 possible_blit++;
             }
         }
@@ -684,8 +690,13 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
         return -1;
     }
 
+    unsigned int blit_layers = possible_blit + 1; /* Account for background layer */
+    int reset_dirty_counters = rgz->rgz_layerno != blit_layers ? 1 : 0;
+
     rgz->state |= RGZ_STATE_INIT;
-    rgz->rgz_layerno = possible_blit + 1; /* Account for background layer */
+    rgz->rgz_layerno = blit_layers;
+
+    rgz_handle_dirty_region(rgz, reset_dirty_counters);
 
     return RGZ_ALL;
 }
-- 
cgit v1.2.3


From e563de0e326074ab07d98384b35ecf7477b5d3df Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 3 Aug 2012 16:30:50 -0500
Subject: hwc: rgz: Remove workaround, Avoid parsing region data if it's not
 needed

This patch removes the workaround introduced by the patch:

2cb90b8 hwc: rgz: Workaround for hdmi hotplug crash with 2D blitter enabled

Basically when the number of layers differ from the ones handled in the
previous frame, we don't trust anymore the region data and we need to
calculate it again. If the layers are the same in number and there has
not been a geometry change the region data can be reused for the same
frame

Change-Id: I4421ca5c7bc1b556cd54de888865ed83e957b919
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 3789ed446d031fbec5fd52ddc0dcde759129ce19)
---
 hwc/rgz_2d.c | 31 +++++++++++++++++--------------
 1 file changed, 17 insertions(+), 14 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 33f04b2..5a74377 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -600,6 +600,17 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     return 1;
 }
 
+/* Reset dirty region data and state */
+static void rgz_delete_region_data(rgz_t *rgz){
+    if (!rgz)
+        return;
+    if (rgz->hregions)
+        free(rgz->hregions);
+    rgz->hregions = NULL;
+    rgz->nhregions = 0;
+    rgz->state &= ~RGZ_REGION_DATA;
+}
+
 static void rgz_handle_dirty_region(rgz_t *rgz, int reset_counters)
 {
     unsigned int i;
@@ -692,6 +703,12 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
 
     unsigned int blit_layers = possible_blit + 1; /* Account for background layer */
     int reset_dirty_counters = rgz->rgz_layerno != blit_layers ? 1 : 0;
+    /*
+     * The layers we are going to blit differ in number from the previous frame,
+     * we can't trust anymore the region data, calculate it again
+     */
+    if (reset_dirty_counters)
+        rgz_delete_region_data(rgz);
 
     rgz->state |= RGZ_STATE_INIT;
     rgz->rgz_layerno = blit_layers;
@@ -713,12 +730,10 @@ static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz)
         return -1;
     }
 
-#if 0
     /* If there is already region data avoid parsing it again */
     if (rgz->state & RGZ_REGION_DATA) {
         return 0;
     }
-#endif
 
     int layerno = rgz->rgz_layerno;
 
@@ -1647,23 +1662,11 @@ int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt)
     return 0;
 }
 
-/* Reset the values needed for every frame, except the dirty region handles */
-static void rgz_reset(rgz_t *rgz){
-    if (!rgz)
-        return;
-    if (rgz->hregions)
-        free(rgz->hregions);
-    rgz->hregions = NULL;
-    rgz->nhregions = 0;
-    rgz->state = 0;
-}
-
 int rgz_in(rgz_in_params_t *p, rgz_t *rgz)
 {
     int rv = -1;
     switch (p->op) {
     case RGZ_IN_HWC:
-        rgz_reset(rgz);
         rv = rgz_in_hwccheck(p, rgz);
         if (rv == RGZ_ALL)
             rv = rgz_in_hwc(p, rgz) ? 0 : RGZ_ALL;
-- 
cgit v1.2.3


From ee551a5488c74639359303d978673405f3522f43 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 24 Aug 2012 18:08:04 -0500
Subject: hwc: rgz: Workaround, do not blit if there is a video layer

This is a workaround for a performance degradation found while
a video is playing and the GC320 is used at the same time.
Avoid blitting if there is a NV12 layer in the hwc layer list.

Change-Id: I12e789b9dd95e8b0d435aac1ae67ff65d4511396
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 52aa03dd27808e773f2133910ae233a1e4d42106)
---
 hwc/rgz_2d.c | 9 +++++++++
 1 file changed, 9 insertions(+)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 5a74377..9da80e5 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -656,6 +656,15 @@ static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
      */
     int l, memidx = 0;
     for (l = 0; l < layerno; l++) {
+        /*
+         * Workaround: If a NV12 layer is present in the list, don't even try
+         * to blit. There is a performance degradation while playing video and
+         * using GC at the same time.
+         */
+        IMG_native_handle_t *handle = (IMG_native_handle_t *)layers[l].handle;
+        if (!(layers[l].flags & HWC_SKIP_LAYER) && handle && is_NV12(handle->iFormat))
+            return -1;
+
         if (layers[l].compositionType == HWC_OVERLAY)
             memidx++;
     }
-- 
cgit v1.2.3


From 970ce449573871c863744391a3909187ee0c128c Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Mon, 23 Jul 2012 16:04:08 -0500
Subject: hwc: rgz: Refactor how the blit parameters are set

This patch basically refactors the way the blit parameters are set
per subregion. The intention is to make the code ready to introduce
the scaling support easier and reduce greatly redundant code as well

Change-Id: I2b32056bf2fec1b636fda1c8df9964d90d51192c
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit d8cd439184093184b21291c37702b3eb7c9c836b)
---
 hwc/rgz_2d.c | 533 +++++++++++++++++++++++------------------------------------
 1 file changed, 206 insertions(+), 327 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 9da80e5..bcd66a3 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -95,12 +95,15 @@ struct rgz_blts {
 };
 
 
-static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff_idx);
+static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer);
 static void rgz_blts_init(struct rgz_blts *blts);
 static void rgz_blts_free(struct rgz_blts *blts);
 static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params);
 static int rgz_blts_bvdirect(rgz_t* rgz, struct rgz_blts *blts, rgz_out_params_t *params);
 static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect);
+static int hal_to_ocd(int color);
+static int rgz_get_orientation(unsigned int transform);
+static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags);
 
 int debug = 0;
 struct rgz_blts blts;
@@ -273,9 +276,7 @@ static int rgz_out_bvdirect_paint(rgz_t *rgz, rgz_out_params_t *params)
 
     /* Begin from index 1 to remove the background layer from the output */
     for (i = 1; i < rgz->rgz_layerno; i++) {
-        hwc_layer_t *l = rgz->rgz_layers[i].hwc_layer;
-
-        rv = rgz_hwc_layer_blit(l, params, -1);
+        rv = rgz_hwc_layer_blit(params, &rgz->rgz_layers[i]);
         if (rv) {
             OUTE("bvdirect_paint: error in layer %d: %d", i, rv);
             dump_all(rgz->rgz_layers, rgz->rgz_layerno, i);
@@ -293,56 +294,197 @@ static void rgz_set_async(struct rgz_blt_entry *e, int async)
     e->bp.flags = async ? e->bp.flags | BVFLAG_ASYNC : e->bp.flags & ~BVFLAG_ASYNC;
 }
 
+static void rgz_get_screen_info(rgz_out_params_t *params, struct bvsurfgeom **screen_geom)
+{
+    *screen_geom = params->data.bvc.dstgeom;
+}
+
+static int rgz_is_blending_disabled(rgz_out_params_t *params)
+{
+    return params->data.bvc.noblend;
+}
+
+static void rgz_set_dst_data(rgz_out_params_t *params, blit_rect_t *subregion_rect,
+    struct rgz_blt_entry* e)
+{
+    struct bvsurfgeom *screen_geom;
+    rgz_get_screen_info(params, &screen_geom);
+
+    /* omaplfb is in charge of assigning the correct dstdesc in the kernel */
+    e->dstgeom.structsize = sizeof(struct bvsurfgeom);
+    e->dstgeom.format = screen_geom->format;
+    e->dstgeom.width = screen_geom->width;
+    e->dstgeom.height = screen_geom->height;
+    e->dstgeom.orientation = screen_geom->orientation;
+    e->dstgeom.virtstride = DSTSTRIDE(screen_geom);
+
+    e->bp.dstrect.left = subregion_rect->left;
+    e->bp.dstrect.top = subregion_rect->top;
+    e->bp.dstrect.width = WIDTH(*subregion_rect);
+    e->bp.dstrect.height = HEIGHT(*subregion_rect);
+}
+
+static void rgz_set_src_data(rgz_out_params_t *params, rgz_layer_t *rgz_layer,
+    blit_rect_t *subregion_rect, struct rgz_blt_entry* e, int is_src2)
+{
+    hwc_layer_t *hwc_layer = rgz_layer->hwc_layer;
+    struct bvbuffdesc *srcdesc = is_src2 ? &e->src2desc : &e->src1desc;
+    struct bvsurfgeom *srcgeom = is_src2 ? &e->src2geom : &e->src1geom;
+    struct bvrect *srcrect = is_src2 ? &e->bp.src2rect : &e->bp.src1rect;
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)hwc_layer->handle;
+
+    srcdesc->structsize = sizeof(struct bvbuffdesc);
+    srcdesc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
+    srcdesc->auxptr = (void*)rgz_layer->buffidx;
+    srcgeom->structsize = sizeof(struct bvsurfgeom);
+    srcgeom->format = hal_to_ocd(handle->iFormat);
+    srcgeom->width = handle->iWidth;
+    srcgeom->height = handle->iHeight;
+    srcgeom->orientation = rgz_get_orientation(hwc_layer->transform);
+    srcgeom->virtstride = HANDLE_TO_STRIDE(handle);
+    if (hwc_layer->transform & HAL_TRANSFORM_ROT_90)
+        swap(srcgeom->width, srcgeom->height);
+
+    /* Find out what portion of the src we want to use for the blit */
+    blit_rect_t res_rect;
+    rgz_get_src_rect(hwc_layer, subregion_rect, &res_rect);
+    srcrect->left = res_rect.left;
+    srcrect->top = res_rect.top;
+    srcrect->width = WIDTH(res_rect);
+    srcrect->height = HEIGHT(res_rect);
+}
+
+/*
+ * Set the clipping rectangle, if part of the subregion rectangle is outside
+ * the boundaries of the destination, remove only the out-of-bounds area
+ */
+static void rgz_set_clip_rect(rgz_out_params_t *params, blit_rect_t *subregion_rect,
+    struct rgz_blt_entry* e)
+{
+    struct bvsurfgeom *screen_geom;
+    rgz_get_screen_info(params, &screen_geom);
+
+    blit_rect_t clip_rect;
+    clip_rect.left = max(0, subregion_rect->left);
+    clip_rect.top = max(0, subregion_rect->top);
+    clip_rect.bottom = min(screen_geom->height, subregion_rect->bottom);
+    clip_rect.right = min(screen_geom->width, subregion_rect->right);
+
+    e->bp.cliprect.left = clip_rect.left;
+    e->bp.cliprect.top = clip_rect.top;
+    e->bp.cliprect.width = WIDTH(clip_rect);
+    e->bp.cliprect.height = HEIGHT(clip_rect);
+}
+
+/*
+ * Configures blit entry to set src2 is the same as the destination
+ */
+static void rgz_set_src2_is_dst(rgz_out_params_t *params, struct rgz_blt_entry* e)
+{
+    /* omaplfb is in charge of assigning the correct src2desc in the kernel */
+    e->src2geom = e->dstgeom;
+    e->src2desc.structsize = sizeof(struct bvbuffdesc);
+    e->src2desc.auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
+    e->bp.src2rect = e->bp.dstrect;
+}
+
+/*
+ * Copies src1 into the framebuffer
+ */
+static struct rgz_blt_entry* rgz_hwc_subregion_copy(rgz_out_params_t *params,
+    blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1)
+{
+    struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+    hwc_layer_t *hwc_src1 = rgz_src1->hwc_layer;
+    e->bp.structsize = sizeof(struct bvbltparams);
+    e->bp.op.rop = 0xCCCC; /* SRCCOPY */
+    e->bp.flags = BVFLAG_CLIP | BVFLAG_ROP;
+    e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0);
+    rgz_set_async(e, 1);
+
+    rgz_set_src_data(params, rgz_src1, subregion_rect, e, 0);
+    rgz_set_dst_data(params, subregion_rect, e);
+    rgz_set_clip_rect(params, subregion_rect, e);
+
+    if((e->src1geom.format == OCDFMT_BGR124) ||
+       (e->src1geom.format == OCDFMT_RGB124) ||
+       (e->src1geom.format == OCDFMT_RGB16))
+        e->dstgeom.format = OCDFMT_BGR124;
+
+    return e;
+}
+
+/*
+ * Blends two layers and write the result in the framebuffer, src1 must be the
+ * top most layer while src2 is the one behind. If src2 is NULL means src1 will
+ * be blended with the current content of the framebuffer.
+ */
+static struct rgz_blt_entry* rgz_hwc_subregion_blend(rgz_out_params_t *params,
+    blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1, rgz_layer_t *rgz_src2)
+{
+    struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+    hwc_layer_t *hwc_src1 = rgz_src1->hwc_layer;
+    e->bp.structsize = sizeof(struct bvbltparams);
+    e->bp.op.blend = BVBLEND_SRC1OVER;
+    e->bp.flags = BVFLAG_CLIP | BVFLAG_BLEND;
+    e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0);
+    rgz_set_async(e, 1);
+
+    rgz_set_src_data(params, rgz_src1, subregion_rect, e, 0);
+    rgz_set_dst_data(params, subregion_rect, e);
+    rgz_set_clip_rect(params, subregion_rect, e);
+
+    if (rgz_src2) {
+        hwc_layer_t *hwc_src2 = rgz_src2->hwc_layer;
+        e->bp.flags |= rgz_get_flip_flags(hwc_src2->transform, 1);
+        rgz_set_src_data(params, rgz_src2, subregion_rect, e, 1);
+    } else
+        rgz_set_src2_is_dst(params, e);
+
+    return e;
+}
+
 /*
  * Clear the destination buffer, if rect is NULL means the whole screen, rect
  * cannot be outside the boundaries of the screen
  */
 static void rgz_out_clrdst(rgz_out_params_t *params, blit_rect_t *rect)
 {
-    struct bvsurfgeom *scrgeom = params->data.bvc.dstgeom;
+    struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+    e->bp.structsize = sizeof(struct bvbltparams);
+    e->bp.op.rop = 0xCCCC; /* SRCCOPY */
+    e->bp.flags = BVFLAG_CLIP | BVFLAG_ROP;
+    rgz_set_async(e, 1);
 
-    struct rgz_blt_entry* e;
-    e = rgz_blts_get(&blts, params);
+    struct bvsurfgeom *screen_geom;
+    rgz_get_screen_info(params, &screen_geom);
 
-    struct bvbuffdesc *src1desc = &e->src1desc;
-    src1desc->structsize = sizeof(struct bvbuffdesc);
-    src1desc->length = 4;
+    e->src1desc.structsize = sizeof(struct bvbuffdesc);
+    e->src1desc.length = 4; /* 1 pixel, 32bpp */
     /*
      * With the HWC we don't bother having a buffer for the fill we'll get the
-     * OMAPLFB to fixup the src1desc if this address is -1
+     * OMAPLFB to fixup the src1desc and stride if the auxiliary pointer is -1
      */
-    src1desc->auxptr = (void*)-1;
-    struct bvsurfgeom *src1geom = &e->src1geom;
-    src1geom->structsize = sizeof(struct bvsurfgeom);
-    src1geom->format = OCDFMT_RGBA24;
-    src1geom->width = src1geom->height = 1;
-    src1geom->orientation = 0;
-    src1geom->virtstride = 1;
-
-    struct bvsurfgeom *dstgeom = &e->dstgeom;
-    dstgeom->structsize = sizeof(struct bvsurfgeom);
-    dstgeom->format = scrgeom->format;
-    dstgeom->width = scrgeom->width;
-    dstgeom->height = scrgeom->height;
-    dstgeom->orientation = 0; /* TODO */
-    dstgeom->virtstride = DSTSTRIDE(scrgeom);
-
-    struct bvbltparams *bp = &e->bp;
-    bp->structsize = sizeof(struct bvbltparams);
-    bp->dstgeom = dstgeom;
-    bp->src1.desc = src1desc;
-    bp->src1geom = src1geom;
-    bp->src1rect.left = 0;
-    bp->src1rect.top = 0;
-    bp->src1rect.width = bp->src1rect.height = 1;
-    bp->cliprect.left = bp->dstrect.left = rect ? rect->left : 0;
-    bp->cliprect.top = bp->dstrect.top = rect ? rect->top : 0;
-    bp->cliprect.width = bp->dstrect.width = rect ? (unsigned int) WIDTH(*rect) : scrgeom->width;
-    bp->cliprect.height = bp->dstrect.height = rect ? (unsigned int) HEIGHT(*rect) : scrgeom->height;
-
-    bp->flags = BVFLAG_CLIP | BVFLAG_ROP;
-    bp->op.rop = 0xCCCC; /* SRCCOPY */
-    rgz_set_async(e, 1);
+    e->src1desc.auxptr = (void*)-1;
+    e->src1geom.structsize = sizeof(struct bvsurfgeom);
+    e->src1geom.format = OCDFMT_RGBA24;
+    e->bp.src1rect.left = e->bp.src1rect.top = e->src1geom.orientation = 0;
+    e->src1geom.height = e->src1geom.width = e->bp.src1rect.height = e->bp.src1rect.width = 1;
+
+    blit_rect_t clear_rect;
+    if (rect) {
+        clear_rect.left = rect->left;
+        clear_rect.top = rect->top;
+        clear_rect.right = rect->right;
+        clear_rect.bottom = rect->bottom;
+    } else {
+        clear_rect.left = clear_rect.top = 0;
+        clear_rect.right = screen_geom->width;
+        clear_rect.bottom = screen_geom->height;
+    }
+
+    rgz_set_dst_data(params, &clear_rect, e);
+    rgz_set_clip_rect(params, &clear_rect, e);
 }
 
 static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
@@ -377,7 +519,7 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
             continue;
         }
 
-        rv = rgz_hwc_layer_blit(l, params, rgz->rgz_layers[i].buffidx);
+        rv = rgz_hwc_layer_blit(params, rgz_layer);
         if (rv) {
             OUTE("bvcmd_paint: error in layer %d: %d", i, rv);
             dump_all(rgz->rgz_layers, rgz->rgz_layerno, i);
@@ -1012,119 +1154,24 @@ static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags)
     return flip_flags;
 }
 
-static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff_idx)
+static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer)
 {
-    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
-    if (!handle || l->flags & HWC_SKIP_LAYER) {
-        /*
-         * This shouldn't happen regionizer should reject compositions w/ skip
-         * layers
-         */
-        OUTP("Cannot handle skip layers\n");
-        return -1;
-    }
     static int loaded = 0;
     if (!loaded)
         loaded = loadbltsville() ? : 1; /* attempt load once */
 
-    struct bvbuffdesc *scrdesc;
-    struct bvsurfgeom *scrgeom;
-    int noblend;
-
-    if (IS_BVCMD(params)) {
-        scrdesc = NULL;
-        scrgeom = params->data.bvc.dstgeom;
-        noblend = params->data.bvc.noblend;
-    } else {
-        scrdesc = params->data.bv.dstdesc;
-        scrgeom = params->data.bv.dstgeom;
-        noblend = params->data.bv.noblend;
-    }
-
-    struct rgz_blt_entry* e;
-    e = rgz_blts_get(&blts, params);
-
-    struct bvbuffdesc *src1desc = &e->src1desc;
-    src1desc->structsize = sizeof(struct bvbuffdesc);
-    src1desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
-    /*
-     * The virtaddr isn't going to be used in the final 2D h/w integration
-     * because we will be handling buffers differently
-     */
-    src1desc->auxptr = buff_idx == -1 ? HANDLE_TO_BUFFER(handle) : (void*)buff_idx; /* FIXME: revisit this later */
-
-    struct bvsurfgeom *src1geom = &e->src1geom;
-    src1geom->structsize = sizeof(struct bvsurfgeom);
-    src1geom->format = hal_to_ocd(handle->iFormat);
-    src1geom->width = handle->iWidth;
-    src1geom->height = handle->iHeight;
-    if (l->transform & HAL_TRANSFORM_ROT_90)
-        swap(src1geom->width, src1geom->height);
-    src1geom->orientation = rgz_get_orientation(l->transform);
-    src1geom->virtstride = HANDLE_TO_STRIDE(handle);
-
-    struct bvsurfgeom *dstgeom = &e->dstgeom;
-    dstgeom->structsize = sizeof(struct bvsurfgeom);
-    dstgeom->format = scrgeom->format;
-    dstgeom->width = scrgeom->width;
-    dstgeom->height = scrgeom->height;
-    /* Destination always set to 0, src buffers will contain rotation values as needed */
-    dstgeom->orientation = 0;
-    dstgeom->virtstride = DSTSTRIDE(scrgeom);
-
-    struct bvbltparams *bp = &e->bp;
-    bp->structsize = sizeof(struct bvbltparams);
-    bp->dstdesc = scrdesc;
-    bp->dstgeom = dstgeom;
-    bp->dstrect.left = l->displayFrame.left;
-    bp->dstrect.top = l->displayFrame.top;
-    bp->dstrect.width = WIDTH(l->displayFrame);
-    bp->dstrect.height = HEIGHT(l->displayFrame);
-    bp->src1.desc = src1desc;
-    bp->src1geom = src1geom;
-    bp->cliprect.left = bp->cliprect.top = 0;
-    bp->cliprect.width = scrgeom->width;
-    bp->cliprect.height = scrgeom->height;
-
-    blit_rect_t src1rect;
-    blit_rect_t src1region;
-    src1region.left = l->displayFrame.left;
-    src1region.top = l->displayFrame.top;
-    src1region.bottom = l->displayFrame.bottom;
-    src1region.right = l->displayFrame.right;
-    rgz_get_src_rect(l, &src1region, &src1rect);
-    bp->src1rect.left = src1rect.left;
-    bp->src1rect.top = src1rect.top;
-    bp->src1rect.width = WIDTH(src1rect);
-    bp->src1rect.height = HEIGHT(src1rect);
-
-    unsigned long bpflags = BVFLAG_CLIP;
-    if (!noblend && l->blending == HWC_BLENDING_PREMULT) {
-        struct bvsurfgeom *src2geom = &e->src2geom;
-        struct bvbuffdesc *src2desc = &e->src2desc;
-        *src2geom = *dstgeom;
-        src2desc->structsize = sizeof(struct bvbuffdesc);
-        src2desc->auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
-        bpflags |= BVFLAG_BLEND;
-        bp->op.blend = BVBLEND_SRC1OVER;
-        bp->src2.desc = scrdesc;
-        bp->src2geom = dstgeom;
-        bp->src2rect.left = l->displayFrame.left;
-        bp->src2rect.top = l->displayFrame.top;
-        bp->src2rect.width = WIDTH(l->displayFrame);
-        bp->src2rect.height = HEIGHT(l->displayFrame);
-    } else {
-        bpflags |= BVFLAG_ROP;
-        bp->op.rop = 0xCCCC; /* SRCCOPY */
-        if((src1geom->format == OCDFMT_BGR124) ||
-           (src1geom->format == OCDFMT_RGB124) ||
-           (src1geom->format == OCDFMT_RGB16))
-            dstgeom->format = OCDFMT_BGR124;
-    }
+    hwc_layer_t* layer = rgz_layer->hwc_layer;
+    blit_rect_t srcregion;
+    srcregion.left = layer->displayFrame.left;
+    srcregion.top = layer->displayFrame.top;
+    srcregion.bottom = layer->displayFrame.bottom;
+    srcregion.right = layer->displayFrame.right;
 
-    bpflags |= rgz_get_flip_flags(l->transform, 0);
-    bp->flags = bpflags;
-    rgz_set_async(e, 1);
+    int noblend = rgz_is_blending_disabled(params);
+    if (!noblend && layer->blending == HWC_BLENDING_PREMULT)
+        rgz_hwc_subregion_blend(params, &srcregion, rgz_layer, NULL);
+    else
+        rgz_hwc_subregion_copy(params, &srcregion, rgz_layer);
 
     return 0;
 }
@@ -1133,14 +1180,9 @@ static int rgz_hwc_layer_blit(hwc_layer_t *l, rgz_out_params_t *params, int buff
  * Calculate the src rectangle on the basis of the layer display, source crop
  * and subregion rectangles. Additionally any rotation will be taken in
  * account. The resulting rectangle is written in res_rect.
- * Note: This doesn't work if the layer is scaled, another approach must be
- * taken in this situation.
  */
 static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect)
 {
-    if (rgz_hwc_scaled(layer))
-        ALOGE("%s: layer %p is scaled", __func__, layer);
-
     IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
     int res_left = 0;
     int res_top = 0;
@@ -1178,132 +1220,6 @@ static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, bl
     res_rect->bottom = res_top + HEIGHT(*subregion_rect);
 }
 
-
-/*
- * Setup the src2 rectangle and the passed descriptor and
- * geometry
- */
-static void rgz_src2blend_prep2(
-    struct rgz_blt_entry* e, unsigned int hwc_transform, blit_rect_t *rect,
-    struct bvbuffdesc *dstdesc, struct bvsurfgeom *dstgeom, int is_fb_dest)
-{
-    unsigned long bpflags = BVFLAG_CLIP;
-
-    struct bvbltparams *bp = &e->bp;
-    bpflags |= BVFLAG_BLEND;
-    bp->op.blend = BVBLEND_SRC1OVER;
-    bp->src2.desc = dstdesc;
-    bp->src2geom = dstgeom;
-
-    if (is_fb_dest) {
-        struct bvsurfgeom *src2geom = &e->src2geom;
-        struct bvbuffdesc *src2desc = &e->src2desc;
-        *src2geom = *dstgeom;
-        src2desc->structsize = sizeof(struct bvbuffdesc);
-        src2desc->auxptr = (void*)HWC_BLT_DESC_FB_FN(0);
-        /* Destination always set to 0, src buffers will contain rotation values as needed */
-        src2geom->orientation = 0;
-        bp->src2rect.left = rect->left;
-        bp->src2rect.top = rect->top;
-        bp->src2rect.width = WIDTH(*rect);
-        bp->src2rect.height = HEIGHT(*rect);
-    } else {
-        struct bvsurfgeom *src2geom = &e->src2geom;
-        src2geom->orientation = rgz_get_orientation(hwc_transform);
-        bpflags |= rgz_get_flip_flags(hwc_transform, 1);
-    }
-
-    bp->flags |= bpflags;
-}
-
-static void rgz_src2blend_prep(
-    struct rgz_blt_entry* e, rgz_layer_t *rgz_layer, blit_rect_t *rect, rgz_out_params_t *params)
-{
-    hwc_layer_t *l = rgz_layer->hwc_layer;
-    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
-
-    struct bvbuffdesc *src2desc = &e->src2desc;
-    src2desc->structsize = sizeof(struct bvbuffdesc);
-    src2desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
-    src2desc->auxptr = IS_BVCMD(params)?
-        (void*)rgz_layer->buffidx : HANDLE_TO_BUFFER(handle);
-
-    struct bvsurfgeom *src2geom = &e->src2geom;
-    src2geom->structsize = sizeof(struct bvsurfgeom);
-    src2geom->format = hal_to_ocd(handle->iFormat);
-    src2geom->width = handle->iWidth;
-    src2geom->height = handle->iHeight;
-    src2geom->virtstride = HANDLE_TO_STRIDE(handle);
-    if (l->transform & HAL_TRANSFORM_ROT_90)
-        swap(src2geom->width, src2geom->height);
-
-    struct bvbltparams *bp = &e->bp;
-    blit_rect_t src2rect;
-    rgz_get_src_rect(l, rect, &src2rect);
-    bp->src2rect.left = src2rect.left;
-    bp->src2rect.top = src2rect.top;
-    bp->src2rect.width = WIDTH(src2rect);
-    bp->src2rect.height = HEIGHT(src2rect);
-
-    rgz_src2blend_prep2(e, l->transform, rect, src2desc, src2geom, 0);
-}
-
-static void rgz_src1_prep(
-    struct rgz_blt_entry* e, rgz_layer_t *rgz_layer,
-    blit_rect_t *rect,
-    struct bvbuffdesc *scrdesc, struct bvsurfgeom *scrgeom, rgz_out_params_t *params)
-{
-    hwc_layer_t *l = rgz_layer->hwc_layer;
-    if (!l)
-        return;
-
-    IMG_native_handle_t *handle = (IMG_native_handle_t *)l->handle;
-
-    struct bvbuffdesc *src1desc = &e->src1desc;
-    src1desc->structsize = sizeof(struct bvbuffdesc);
-    src1desc->length = handle->iHeight * HANDLE_TO_STRIDE(handle);
-    src1desc->auxptr = IS_BVCMD(params) ?
-        (void*)rgz_layer->buffidx : HANDLE_TO_BUFFER(handle);
-
-    struct bvsurfgeom *src1geom = &e->src1geom;
-    src1geom->structsize = sizeof(struct bvsurfgeom);
-    src1geom->format = hal_to_ocd(handle->iFormat);
-    src1geom->width = handle->iWidth;
-    src1geom->height = handle->iHeight;
-    src1geom->orientation = rgz_get_orientation(l->transform);
-    src1geom->virtstride = HANDLE_TO_STRIDE(handle);
-    if (l->transform & HAL_TRANSFORM_ROT_90)
-        swap(src1geom->width, src1geom->height);
-
-    struct bvsurfgeom *dstgeom = &e->dstgeom;
-    dstgeom->structsize = sizeof(struct bvsurfgeom);
-    dstgeom->format = scrgeom->format;
-    dstgeom->width = scrgeom->width;
-    dstgeom->height = scrgeom->height;
-    /* Destination always set to 0, src buffers will contain rotation values as needed */
-    dstgeom->orientation = 0;
-    dstgeom->virtstride = DSTSTRIDE(scrgeom);
-
-    struct bvbltparams *bp = &e->bp;
-    bp->structsize = sizeof(struct bvbltparams);
-    bp->dstdesc = scrdesc;
-    bp->dstgeom = dstgeom;
-    bp->cliprect.left = bp->dstrect.left = rect->left;
-    bp->cliprect.top = bp->dstrect.top = rect->top;
-    bp->cliprect.width = bp->dstrect.width = WIDTH(*rect);
-    bp->cliprect.height = bp->dstrect.height = HEIGHT(*rect);
-    bp->src1.desc = src1desc;
-    bp->src1geom = src1geom;
-
-    blit_rect_t src1rect;
-    rgz_get_src_rect(l, rect, &src1rect);
-    bp->src1rect.left = src1rect.left;
-    bp->src1rect.top = src1rect.top;
-    bp->src1rect.width = WIDTH(src1rect);
-    bp->src1rect.height = HEIGHT(src1rect);
-    bp->flags |= rgz_get_flip_flags(l->transform, 0);
-}
-
 static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned int set)
 {
     e->bp.flags &= ~BVFLAG_BATCH_MASK;
@@ -1317,20 +1233,6 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
     if (!loaded)
         loaded = loadbltsville() ? : 1; /* attempt load once */
 
-    struct bvbuffdesc *scrdesc;
-    struct bvsurfgeom *scrgeom;
-    int noblend;
-
-    if (IS_BVCMD(params)) {
-        scrdesc = NULL;
-        scrgeom = params->data.bvc.dstgeom;
-        noblend = params->data.bvc.noblend;
-    } else {
-        scrdesc = params->data.bv.dstdesc;
-        scrgeom = params->data.bv.dstgeom;
-        noblend = params->data.bv.noblend;
-    }
-
     int lix;
     int ldepth = get_layer_ops(hregion, sidx, &lix);
     if (ldepth == 0) {
@@ -1384,9 +1286,11 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         lix = get_layer_ops_next(hregion, sidx, lix);
     }
 
+    int noblend = rgz_is_blending_disabled(params);
+
     if (!noblend && ldepth > 1) { /* BLEND */
         blit_rect_t *rect = &hregion->blitrects[lix][sidx];
-        struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
+        struct rgz_blt_entry* e;
 
         int s2lix = lix;
         lix = get_layer_ops_next(hregion, sidx, lix);
@@ -1395,31 +1299,21 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
          * We save a read and a write from the FB if we blend the bottom
          * two layers
          */
-        rgz_src1_prep(e, hregion->rgz_layers[lix], rect, scrdesc, scrgeom, params);
-        rgz_src2blend_prep(e, hregion->rgz_layers[s2lix], rect, params);
+        e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix],
+            hregion->rgz_layers[s2lix]);
         rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0);
-        rgz_set_async(e, 1);
 
         /* Rest of layers blended with FB */
         int first = 1;
         while((lix = get_layer_ops_next(hregion, sidx, lix)) != -1) {
             int batchflags = 0;
-            e = rgz_blts_get(&blts, params);
-
-            rgz_layer_t *rgz_layer = hregion->rgz_layers[lix];
-            hwc_layer_t *layer = rgz_layer->hwc_layer;
-            rgz_src1_prep(e, rgz_layer, rect, scrdesc, scrgeom, params);
-            rgz_src2blend_prep2(e, layer->transform, rect, scrdesc, scrgeom, 1);
-
+            e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix], NULL);
             if (first) {
                 first = 0;
                 batchflags |= BVBATCH_SRC2 | BVBATCH_SRC2RECT_ORIGIN;
             }
             batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN;
-            if (rgz_hwc_scaled(layer))
-                batchflags |= BVBATCH_SRC1RECT_ORIGIN | BVBATCH_SRC1RECT_SIZE;
             rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags);
-            rgz_set_async(e, 1);
         }
 
         if (e->bp.flags & BVFLAG_BATCH_BEGIN)
@@ -1431,23 +1325,7 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
         blit_rect_t *rect = &hregion->blitrects[lix][sidx];
         if (noblend)    /* get_layer_ops() doesn't understand this so get the top */
             lix = get_top_rect(hregion, sidx, &rect);
-
-        struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
-
-        rgz_layer_t *rgz_layer = hregion->rgz_layers[lix];
-        hwc_layer_t *l = rgz_layer->hwc_layer;
-        rgz_src1_prep(e, rgz_layer, rect, scrdesc, scrgeom, params);
-
-        struct bvsurfgeom *src1geom = &e->src1geom;
-        unsigned long bpflags = BVFLAG_CLIP | BVFLAG_ROP;
-        e->bp.op.rop = 0xCCCC; /* SRCCOPY */
-        if((src1geom->format == OCDFMT_BGR124) ||
-           (src1geom->format == OCDFMT_RGB124) ||
-           (src1geom->format == OCDFMT_RGB16))
-            e->dstgeom.format = OCDFMT_BGR124;
-
-        rgz_set_async(e, 1);
-        e->bp.flags |= bpflags;
+        rgz_hwc_subregion_copy(params, rect, hregion->rgz_layers[lix]);
     }
     return 0;
 }
@@ -1667,6 +1545,7 @@ int rgz_get_screengeometry(int fd, struct bvsurfgeom *geom, int fmt)
     geom->height = fb_varinfo.yres;
     geom->virtstride = fb_fixinfo.line_length;
     geom->format = hal_to_ocd(fmt);
+    /* Always set to 0, src buffers will contain rotation values as needed */
     geom->orientation = 0;
     return 0;
 }
-- 
cgit v1.2.3


From 935e618471b2ab77c8809354ed6838c067667fe4 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Wed, 25 Jul 2012 18:32:09 -0500
Subject: hwc: rgz: Introduce scaling support

Adds scaling support to the regionizer code.

Limitations:

+ When blending two layers with scaling two blits are issued
  instead of one. This is due to a Bltsville API limitation
  which prevents specifying two different scale modes for each
  source.
+ Support for scaling and rotation on the same blit is not
  possible yet due to a GC driver bug.

Change-Id: Ie53157e527dacf639e42a72e371ef962f888131c
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit ad4ba4604f3f9bafed27c83b3c0a49d8731dddd7)
---
 hwc/rgz_2d.c | 115 +++++++++++++++++++++++++++++++++++++++++++++++++----------
 1 file changed, 96 insertions(+), 19 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index bcd66a3..8cd8956 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -104,6 +104,7 @@ static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, bl
 static int hal_to_ocd(int color);
 static int rgz_get_orientation(unsigned int transform);
 static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags);
+static int rgz_hwc_scaled(hwc_layer_t *layer);
 
 int debug = 0;
 struct rgz_blts blts;
@@ -304,6 +305,14 @@ static int rgz_is_blending_disabled(rgz_out_params_t *params)
     return params->data.bvc.noblend;
 }
 
+static void rgz_get_displayframe_rect(hwc_layer_t *layer, blit_rect_t *res_rect)
+{
+    res_rect->left = layer->displayFrame.left;
+    res_rect->top = layer->displayFrame.top;
+    res_rect->bottom = layer->displayFrame.bottom;
+    res_rect->right = layer->displayFrame.right;
+}
+
 static void rgz_set_dst_data(rgz_out_params_t *params, blit_rect_t *subregion_rect,
     struct rgz_blt_entry* e)
 {
@@ -388,6 +397,19 @@ static void rgz_set_src2_is_dst(rgz_out_params_t *params, struct rgz_blt_entry*
     e->bp.src2rect = e->bp.dstrect;
 }
 
+/*
+ * Configure the scaling mode according to the layer format
+ */
+static void rgz_cfg_scale_mode(struct rgz_blt_entry* e, hwc_layer_t *layer)
+{
+    /*
+     * TODO: Revisit scaling mode assignment later, output between GPU and GC320
+     * seem different
+     */
+    IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
+    e->bp.scalemode = is_NV12(handle->iFormat) ? BVSCALE_9x9_TAP : BVSCALE_BILINEAR;
+}
+
 /*
  * Copies src1 into the framebuffer
  */
@@ -402,8 +424,15 @@ static struct rgz_blt_entry* rgz_hwc_subregion_copy(rgz_out_params_t *params,
     e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0);
     rgz_set_async(e, 1);
 
-    rgz_set_src_data(params, rgz_src1, subregion_rect, e, 0);
-    rgz_set_dst_data(params, subregion_rect, e);
+    blit_rect_t tmp_rect;
+    if (rgz_hwc_scaled(hwc_src1)) {
+        rgz_get_displayframe_rect(hwc_src1, &tmp_rect);
+        rgz_cfg_scale_mode(e, hwc_src1);
+    } else
+        tmp_rect = *subregion_rect;
+
+    rgz_set_src_data(params, rgz_src1, &tmp_rect, e, 0);
+    rgz_set_dst_data(params, &tmp_rect, e);
     rgz_set_clip_rect(params, subregion_rect, e);
 
     if((e->src1geom.format == OCDFMT_BGR124) ||
@@ -430,12 +459,25 @@ static struct rgz_blt_entry* rgz_hwc_subregion_blend(rgz_out_params_t *params,
     e->bp.flags |= rgz_get_flip_flags(hwc_src1->transform, 0);
     rgz_set_async(e, 1);
 
-    rgz_set_src_data(params, rgz_src1, subregion_rect, e, 0);
-    rgz_set_dst_data(params, subregion_rect, e);
+    blit_rect_t tmp_rect;
+    if (rgz_hwc_scaled(hwc_src1)) {
+        rgz_get_displayframe_rect(hwc_src1, &tmp_rect);
+        rgz_cfg_scale_mode(e, hwc_src1);
+    } else
+        tmp_rect = *subregion_rect;
+
+    rgz_set_src_data(params, rgz_src1, &tmp_rect, e, 0);
+    rgz_set_dst_data(params, &tmp_rect, e);
     rgz_set_clip_rect(params, subregion_rect, e);
 
     if (rgz_src2) {
+        /*
+         * NOTE: Due to an API limitation it's not possible to blend src1 and
+         * src2 if both have scaling, hence only src1 is used for now
+         */
         hwc_layer_t *hwc_src2 = rgz_src2->hwc_layer;
+        if (rgz_hwc_scaled(hwc_src2))
+            OUTE("src2 layer %p has scaling, this is not supported", hwc_src2);
         e->bp.flags |= rgz_get_flip_flags(hwc_src2->transform, 1);
         rgz_set_src_data(params, rgz_src2, subregion_rect, e, 1);
     } else
@@ -711,11 +753,12 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     if ((layer->flags & HWC_SKIP_LAYER) || !handle)
         return 0;
 
-    if (rgz_hwc_scaled(layer))
+    /* FIXME: GC doesn't support layers with scaling and rotation on the same blit yet */
+    if (rgz_hwc_scaled(layer) && layer->transform)
         return 0;
 
     if (is_NV12(handle->iFormat))
-        return (!layer->transform && handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12);
+        return handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12;
 
     /* FIXME: The following must be removed when GC supports vertical/horizontal
      * buffer flips, please note having a FLIP_H and FLIP_V means 180 rotation
@@ -1162,10 +1205,7 @@ static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer)
 
     hwc_layer_t* layer = rgz_layer->hwc_layer;
     blit_rect_t srcregion;
-    srcregion.left = layer->displayFrame.left;
-    srcregion.top = layer->displayFrame.top;
-    srcregion.bottom = layer->displayFrame.bottom;
-    srcregion.right = layer->displayFrame.right;
+    rgz_get_displayframe_rect(layer, &srcregion);
 
     int noblend = rgz_is_blending_disabled(params);
     if (!noblend && layer->blending == HWC_BLENDING_PREMULT)
@@ -1186,8 +1226,29 @@ static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, bl
     IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
     int res_left = 0;
     int res_top = 0;
-    int delta_left = subregion_rect->left - layer->displayFrame.left;
-    int delta_top = subregion_rect->top - layer->displayFrame.top;
+    int delta_left;
+    int delta_top;
+    int res_width;
+    int res_height;
+
+    /*
+     * If the layer is scaled we use the whole cropping rectangle from the
+     * source and just move the clipping rectangle for the region we want to
+     * blit, this is done to prevent any artifacts when blitting subregions of
+     * a scaled layer
+     */
+    if (rgz_hwc_scaled(layer)) {
+        delta_top = 0;
+        delta_left = 0;
+        res_width = WIDTH(layer->sourceCrop);
+        res_height = HEIGHT(layer->sourceCrop);
+    } else {
+        delta_top = subregion_rect->top - layer->displayFrame.top;
+        delta_left = subregion_rect->left - layer->displayFrame.left;
+        res_width = WIDTH(*subregion_rect);
+        res_height = HEIGHT(*subregion_rect);
+    }
+
     /*
      * Calculate the top, left offset from the source cropping rectangle
      * depending on the rotation
@@ -1216,8 +1277,8 @@ static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, bl
     /* Resulting rectangle has the subregion dimensions */
     res_rect->left = res_left;
     res_rect->top = res_top;
-    res_rect->right = res_left + WIDTH(*subregion_rect);
-    res_rect->bottom = res_top + HEIGHT(*subregion_rect);
+    res_rect->right = res_left + res_width;
+    res_rect->bottom = res_top + res_height;
 }
 
 static void rgz_batch_entry(struct rgz_blt_entry* e, unsigned int flag, unsigned int set)
@@ -1297,10 +1358,20 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
 
         /*
          * We save a read and a write from the FB if we blend the bottom
-         * two layers
+         * two layers, we can do this only if both layers are not scaled
          */
-        e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix],
-            hregion->rgz_layers[s2lix]);
+        int first_batchflags = 0;
+        if (!rgz_hwc_scaled(hregion->rgz_layers[lix]->hwc_layer) &&
+            !rgz_hwc_scaled(hregion->rgz_layers[s2lix]->hwc_layer)) {
+            e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix],
+                hregion->rgz_layers[s2lix]);
+            first_batchflags |= BVBATCH_SRC2;
+        } else {
+            /* Return index to the first operation and make a copy of the first layer */
+            lix = s2lix;
+            e = rgz_hwc_subregion_copy(params, rect, hregion->rgz_layers[lix]);
+            first_batchflags |= BVBATCH_OP | BVBATCH_SRC2;
+        }
         rgz_batch_entry(e, BVFLAG_BATCH_BEGIN, 0);
 
         /* Rest of layers blended with FB */
@@ -1310,9 +1381,15 @@ static int rgz_hwc_subregion_blit(blit_hregion_t *hregion, int sidx, rgz_out_par
             e = rgz_hwc_subregion_blend(params, rect, hregion->rgz_layers[lix], NULL);
             if (first) {
                 first = 0;
-                batchflags |= BVBATCH_SRC2 | BVBATCH_SRC2RECT_ORIGIN;
+                batchflags |= first_batchflags;
             }
-            batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN;
+            /*
+             * TODO: This will work when scaling is introduced, however we need
+             * to think on a better way to optimize this.
+             */
+            batchflags |= BVBATCH_SRC1 | BVBATCH_SRC1RECT_ORIGIN| BVBATCH_SRC1RECT_SIZE |
+                BVBATCH_DSTRECT_ORIGIN | BVBATCH_DSTRECT_SIZE | BVBATCH_SRC2RECT_ORIGIN |
+                BVBATCH_SRC2RECT_SIZE | BVBATCH_SCALE;
             rgz_batch_entry(e, BVFLAG_BATCH_CONTINUE, batchflags);
         }
 
-- 
cgit v1.2.3


From 2e285518874217f7e04bd79cb5090c780c5c34ad Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Thu, 20 Sep 2012 15:06:23 -0500
Subject: hwc: rgz: Allow scaling and rotation on the same blit

Allow blitting layers that have scaling and a transformation now that
the GC driver supports it.

Change-Id: Iee5a34dc888656c47b3b514597b75868ccdc008a
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit c195634f79fb5a49b0caa33a4f9605a3aa40efe2)
---
 hwc/rgz_2d.c | 4 ----
 1 file changed, 4 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 8cd8956..60cc8a6 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -753,10 +753,6 @@ static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
     if ((layer->flags & HWC_SKIP_LAYER) || !handle)
         return 0;
 
-    /* FIXME: GC doesn't support layers with scaling and rotation on the same blit yet */
-    if (rgz_hwc_scaled(layer) && layer->transform)
-        return 0;
-
     if (is_NV12(handle->iFormat))
         return handle->iFormat == HAL_PIXEL_FORMAT_TI_NV12;
 
-- 
cgit v1.2.3


From 42428ff2ee69e996b145a3b6c9d5791e0cef45e7 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Fri, 21 Sep 2012 18:05:11 -0500
Subject: hwc: rgz: Fix incorrect src rectangle calculation for scaled layers

When scaling a layer, the blit is programmed in a way where the src
rectangle uses the whole cropping rectangle coordinates and
dimensions. However if the layer has a transform, the width and the
height need to be swapped not only in the geometry but also in the
src rectangle to match the new dimensions.

This patch adds the missing width and height swapping for the
src rectangle if the transformation is 90 or 270 degrees.

Change-Id: Ia9d822b6698210573fff662f2fcb129dfc048bf7
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit a80084da8fb2c63a2e44ef9d4ce7598b7cad853f)
---
 hwc/rgz_2d.c | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 60cc8a6..5c4d1a9 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -1231,13 +1231,16 @@ static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, bl
      * If the layer is scaled we use the whole cropping rectangle from the
      * source and just move the clipping rectangle for the region we want to
      * blit, this is done to prevent any artifacts when blitting subregions of
-     * a scaled layer
+     * a scaled layer. If there is a transform, adjust the width and height
+     * accordingly to match the rotated buffer geometry.
      */
     if (rgz_hwc_scaled(layer)) {
         delta_top = 0;
         delta_left = 0;
         res_width = WIDTH(layer->sourceCrop);
         res_height = HEIGHT(layer->sourceCrop);
+        if (layer->transform & HAL_TRANSFORM_ROT_90)
+            swap(res_width , res_height);
     } else {
         delta_top = subregion_rect->top - layer->displayFrame.top;
         delta_left = subregion_rect->left - layer->displayFrame.left;
-- 
cgit v1.2.3


From 54712e460cc3b292e5cacb7ce9dd9bd96321e5f9 Mon Sep 17 00:00:00 2001
From: Gustavo Diaz Prado <a0273371@ti.com>
Date: Wed, 3 Oct 2012 11:47:47 -0500
Subject: hwc: rgz: Fix using an invalid array index when there are no blits

When the regionizer decides there are no blits as a result of a given
hwc geometry a -1 array index was being used to set the last blit
async, this needs to be avoided if there are no blits.

Change-Id: I3ce2f60a46096559c2ba308cf1d617a79731751e
Signed-off-by: Gustavo Diaz Prado <a0273371@ti.com>
(cherry picked from commit 8d486cd705ffc33d6048880189e16fed387338fd)
---
 hwc/rgz_2d.c | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 5c4d1a9..96c4374 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -1510,9 +1510,11 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
             params->data.bvc.out_nhndls++;
         }
 
-        /* Last blit is made sync to act like a fence for the previous async blits */
-        struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1];
-        rgz_set_async(e, 0);
+        if (blts.idx > 0) {
+            /* Last blit is made sync to act like a fence for the previous async blits */
+            struct rgz_blt_entry* e = &blts.bvcmds[blts.idx-1];
+            rgz_set_async(e, 0);
+        }
 
         /* FIXME: we want to be able to call rgz_blts_free and populate the actual
          * composition data structure ourselves */
-- 
cgit v1.2.3


From 284005c3a0e0b21f28febca5ad1dd647f912d9fe Mon Sep 17 00:00:00 2001
From: Jason Simmons <jsimmons@google.com>
Date: Mon, 22 Oct 2012 16:21:12 -0700
Subject: Fix warnings due to updated definitions of hwc_* types in the HWC HAL
 interface

Change-Id: I8954125e75c1f0ee469ec035ebe0376139aef1e9
---
 hwc/rgz_2d.c | 59 +++++++++++++++++++++++++++++------------------------------
 1 file changed, 29 insertions(+), 30 deletions(-)

(limited to 'hwc/rgz_2d.c')

diff --git a/hwc/rgz_2d.c b/hwc/rgz_2d.c
index 96c4374..4f9e483 100644
--- a/hwc/rgz_2d.c
+++ b/hwc/rgz_2d.c
@@ -100,16 +100,16 @@ static void rgz_blts_init(struct rgz_blts *blts);
 static void rgz_blts_free(struct rgz_blts *blts);
 static struct rgz_blt_entry* rgz_blts_get(struct rgz_blts *blts, rgz_out_params_t *params);
 static int rgz_blts_bvdirect(rgz_t* rgz, struct rgz_blts *blts, rgz_out_params_t *params);
-static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect);
+static void rgz_get_src_rect(hwc_layer_1_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect);
 static int hal_to_ocd(int color);
 static int rgz_get_orientation(unsigned int transform);
 static int rgz_get_flip_flags(unsigned int transform, int use_src2_flags);
-static int rgz_hwc_scaled(hwc_layer_t *layer);
+static int rgz_hwc_scaled(hwc_layer_1_t *layer);
 
 int debug = 0;
 struct rgz_blts blts;
 /* Represents a screen sized background layer */
-static hwc_layer_t bg_layer;
+static hwc_layer_1_t bg_layer;
 
 static void svgout_header(int htmlw, int htmlh, int coordw, int coordh)
 {
@@ -169,7 +169,7 @@ static int get_layer_ops(blit_hregion_t *hregion, int subregion, int *bottom)
         if (!empty_rect(&hregion->blitrects[l][subregion])) {
             ops++;
             *bottom = l;
-            hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+            hwc_layer_1_t *layer = hregion->rgz_layers[l]->hwc_layer;
             IMG_native_handle_t *h = (IMG_native_handle_t *)layer->handle;
             if ((layer->blending != HWC_BLENDING_PREMULT) || is_OPAQUE(h->iFormat))
                 break;
@@ -228,7 +228,7 @@ static void rgz_out_svg(rgz_t *rgz, rgz_out_params_t *params)
 }
 
 /* XXX duplicate of hwc.c version */
-static void dump_layer(hwc_layer_t const* l, int iserr)
+static void dump_layer(hwc_layer_1_t const* l, int iserr)
 {
 #define FMT(f) ((f) == HAL_PIXEL_FORMAT_TI_NV12 ? "NV12" : \
                 (f) == HAL_PIXEL_FORMAT_BGRX_8888 ? "xRGB32" : \
@@ -261,7 +261,7 @@ static void dump_all(rgz_layer_t *rgz_layers, unsigned int layerno, unsigned int
 {
     unsigned int i;
     for (i = 0; i < layerno; i++) {
-        hwc_layer_t *l = rgz_layers[i].hwc_layer;
+        hwc_layer_1_t *l = rgz_layers[i].hwc_layer;
         OUTE("Layer %d", i);
         dump_layer(l, errlayer == i);
     }
@@ -305,7 +305,7 @@ static int rgz_is_blending_disabled(rgz_out_params_t *params)
     return params->data.bvc.noblend;
 }
 
-static void rgz_get_displayframe_rect(hwc_layer_t *layer, blit_rect_t *res_rect)
+static void rgz_get_displayframe_rect(hwc_layer_1_t *layer, blit_rect_t *res_rect)
 {
     res_rect->left = layer->displayFrame.left;
     res_rect->top = layer->displayFrame.top;
@@ -336,7 +336,7 @@ static void rgz_set_dst_data(rgz_out_params_t *params, blit_rect_t *subregion_re
 static void rgz_set_src_data(rgz_out_params_t *params, rgz_layer_t *rgz_layer,
     blit_rect_t *subregion_rect, struct rgz_blt_entry* e, int is_src2)
 {
-    hwc_layer_t *hwc_layer = rgz_layer->hwc_layer;
+    hwc_layer_1_t *hwc_layer = rgz_layer->hwc_layer;
     struct bvbuffdesc *srcdesc = is_src2 ? &e->src2desc : &e->src1desc;
     struct bvsurfgeom *srcgeom = is_src2 ? &e->src2geom : &e->src1geom;
     struct bvrect *srcrect = is_src2 ? &e->bp.src2rect : &e->bp.src1rect;
@@ -400,7 +400,7 @@ static void rgz_set_src2_is_dst(rgz_out_params_t *params, struct rgz_blt_entry*
 /*
  * Configure the scaling mode according to the layer format
  */
-static void rgz_cfg_scale_mode(struct rgz_blt_entry* e, hwc_layer_t *layer)
+static void rgz_cfg_scale_mode(struct rgz_blt_entry* e, hwc_layer_1_t *layer)
 {
     /*
      * TODO: Revisit scaling mode assignment later, output between GPU and GC320
@@ -417,7 +417,7 @@ static struct rgz_blt_entry* rgz_hwc_subregion_copy(rgz_out_params_t *params,
     blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1)
 {
     struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
-    hwc_layer_t *hwc_src1 = rgz_src1->hwc_layer;
+    hwc_layer_1_t *hwc_src1 = rgz_src1->hwc_layer;
     e->bp.structsize = sizeof(struct bvbltparams);
     e->bp.op.rop = 0xCCCC; /* SRCCOPY */
     e->bp.flags = BVFLAG_CLIP | BVFLAG_ROP;
@@ -452,7 +452,7 @@ static struct rgz_blt_entry* rgz_hwc_subregion_blend(rgz_out_params_t *params,
     blit_rect_t *subregion_rect, rgz_layer_t *rgz_src1, rgz_layer_t *rgz_src2)
 {
     struct rgz_blt_entry* e = rgz_blts_get(&blts, params);
-    hwc_layer_t *hwc_src1 = rgz_src1->hwc_layer;
+    hwc_layer_1_t *hwc_src1 = rgz_src1->hwc_layer;
     e->bp.structsize = sizeof(struct bvbltparams);
     e->bp.op.blend = BVBLEND_SRC1OVER;
     e->bp.flags = BVFLAG_CLIP | BVFLAG_BLEND;
@@ -475,7 +475,7 @@ static struct rgz_blt_entry* rgz_hwc_subregion_blend(rgz_out_params_t *params,
          * NOTE: Due to an API limitation it's not possible to blend src1 and
          * src2 if both have scaling, hence only src1 is used for now
          */
-        hwc_layer_t *hwc_src2 = rgz_src2->hwc_layer;
+        hwc_layer_1_t *hwc_src2 = rgz_src2->hwc_layer;
         if (rgz_hwc_scaled(hwc_src2))
             OUTE("src2 layer %p has scaling, this is not supported", hwc_src2);
         e->bp.flags |= rgz_get_flip_flags(hwc_src2->transform, 1);
@@ -542,7 +542,7 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
     /* Begin from index 1 to remove the background layer from the output */
     for (i = 1, j = 0; i < rgz->rgz_layerno; i++) {
         rgz_layer_t *rgz_layer = &rgz->rgz_layers[i];
-        hwc_layer_t *l = rgz_layer->hwc_layer;
+        hwc_layer_1_t *l = rgz_layer->hwc_layer;
 
         //OUTP("blitting meminfo %d", rgz->rgz_layers[i].buffidx);
 
@@ -588,7 +588,7 @@ static int rgz_out_bvcmd_paint(rgz_t *rgz, rgz_out_params_t *params)
     return rv;
 }
 
-static float getscalew(hwc_layer_t *layer)
+static float getscalew(hwc_layer_1_t *layer)
 {
     int w = WIDTH(layer->sourceCrop);
     int h = HEIGHT(layer->sourceCrop);
@@ -599,7 +599,7 @@ static float getscalew(hwc_layer_t *layer)
     return ((float)WIDTH(layer->displayFrame)) / (float)w;
 }
 
-static float getscaleh(hwc_layer_t *layer)
+static float getscaleh(hwc_layer_1_t *layer)
 {
     int w = WIDTH(layer->sourceCrop);
     int h = HEIGHT(layer->sourceCrop);
@@ -667,7 +667,7 @@ static int rgz_hwc_layer_sortbyy(rgz_layer_t *ra, int rsz, int *out, int *width,
     int i;
     *width = 0;
     for (i = 0; i < rsz; i++) {
-        hwc_layer_t *layer = ra[i].hwc_layer;
+        hwc_layer_1_t *layer = ra[i].hwc_layer;
         /* Maintain regions inside display boundaries */
         int top = layer->displayFrame.top;
         int bottom = layer->displayFrame.bottom;
@@ -700,7 +700,7 @@ static void rgz_gen_blitregions(blit_hregion_t *hregion, int screen_width)
     int noffsets=0;
     int l, r;
     for (l = 0; l < hregion->nlayers; l++) {
-        hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+        hwc_layer_1_t *layer = hregion->rgz_layers[l]->hwc_layer;
         /* Make sure the subregion is not outside the boundaries of the screen */
         int left = layer->displayFrame.left;
         int right = layer->displayFrame.right;
@@ -721,7 +721,7 @@ static void rgz_gen_blitregions(blit_hregion_t *hregion, int screen_width)
         ALOGD_IF(debug, "                sub l %d r %d",
             subregion.left, subregion.right);
         for (l = 0; l < hregion->nlayers; l++) {
-            hwc_layer_t *layer = hregion->rgz_layers[l]->hwc_layer;
+            hwc_layer_1_t *layer = hregion->rgz_layers[l]->hwc_layer;
             if (rgz_hwc_intersects(&subregion, &layer->displayFrame)) {
 
                 hregion->blitrects[l][r] = subregion;
@@ -736,7 +736,7 @@ static void rgz_gen_blitregions(blit_hregion_t *hregion, int screen_width)
     }
 }
 
-static int rgz_hwc_scaled(hwc_layer_t *layer)
+static int rgz_hwc_scaled(hwc_layer_1_t *layer)
 {
     int w = WIDTH(layer->sourceCrop);
     int h = HEIGHT(layer->sourceCrop);
@@ -747,7 +747,7 @@ static int rgz_hwc_scaled(hwc_layer_t *layer)
     return WIDTH(layer->displayFrame) != w || HEIGHT(layer->displayFrame) != h;
 }
 
-static int rgz_in_valid_hwc_layer(hwc_layer_t *layer)
+static int rgz_in_valid_hwc_layer(hwc_layer_1_t *layer)
 {
     IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
     if ((layer->flags & HWC_SKIP_LAYER) || !handle)
@@ -820,7 +820,7 @@ static void rgz_handle_dirty_region(rgz_t *rgz, int reset_counters)
 
 static int rgz_in_hwccheck(rgz_in_params_t *p, rgz_t *rgz)
 {
-    hwc_layer_t *layers = p->data.hwc.layers;
+    hwc_layer_1_t *layers = p->data.hwc.layers;
     int layerno = p->data.hwc.layerno;
 
     rgz->state &= ~RGZ_STATE_INIT;
@@ -953,7 +953,7 @@ static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz)
         hregions[i].rect.right = dispw > screen_width ? screen_width : dispw;
         hregions[i].nlayers = 0;
         for (j = 0; j < layerno; j++) {
-            hwc_layer_t *layer = rgz_layers[j].hwc_layer;
+            hwc_layer_1_t *layer = rgz_layers[j].hwc_layer;
             if (rgz_hwc_intersects(&hregions[i].rect, &layer->displayFrame)) {
                 int l = hregions[i].nlayers++;
                 hregions[i].rgz_layers[l] = &rgz_layers[j];
@@ -981,7 +981,7 @@ static int rgz_in_hwc(rgz_in_params_t *p, rgz_t *rgz)
  * dright, dbot, rot, flip, blending, scalew, scaleh, visrects
  *
  */
-static void rgz_print_layer(hwc_layer_t *l, int idx, int csv)
+static void rgz_print_layer(hwc_layer_1_t *l, int idx, int csv)
 {
     char big_log[1024];
     int e = sizeof(big_log);
@@ -1079,11 +1079,11 @@ static void rgz_print_layer(hwc_layer_t *l, int idx, int csv)
     }
 }
 
-static void rgz_print_layers(hwc_layer_list_t* list, int csv)
+static void rgz_print_layers(hwc_display_contents_1_t* list, int csv)
 {
     size_t i;
     for (i = 0; i < list->numHwLayers; i++) {
-        hwc_layer_t *l = &list->hwLayers[i];
+        hwc_layer_1_t *l = &list->hwLayers[i];
         rgz_print_layer(l, i, csv);
     }
 }
@@ -1199,7 +1199,7 @@ static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer)
     if (!loaded)
         loaded = loadbltsville() ? : 1; /* attempt load once */
 
-    hwc_layer_t* layer = rgz_layer->hwc_layer;
+    hwc_layer_1_t* layer = rgz_layer->hwc_layer;
     blit_rect_t srcregion;
     rgz_get_displayframe_rect(layer, &srcregion);
 
@@ -1217,7 +1217,7 @@ static int rgz_hwc_layer_blit(rgz_out_params_t *params, rgz_layer_t *rgz_layer)
  * and subregion rectangles. Additionally any rotation will be taken in
  * account. The resulting rectangle is written in res_rect.
  */
-static void rgz_get_src_rect(hwc_layer_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect)
+static void rgz_get_src_rect(hwc_layer_1_t* layer, blit_rect_t *subregion_rect, blit_rect_t *res_rect)
 {
     IMG_native_handle_t *handle = (IMG_native_handle_t *)layer->handle;
     int res_left = 0;
@@ -1505,7 +1505,7 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
             /* We don't need the handles for layers marked as -1 */
             if (rgz_layer->buffidx == -1)
                 continue;
-            hwc_layer_t *layer = rgz_layer->hwc_layer;
+            hwc_layer_1_t *layer = rgz_layer->hwc_layer;
             params->data.bvc.out_hndls[i++] = layer->handle;
             params->data.bvc.out_nhndls++;
         }
@@ -1531,7 +1531,7 @@ static int rgz_out_region(rgz_t *rgz, rgz_out_params_t *params)
     return rv;
 }
 
-void rgz_profile_hwc(hwc_layer_list_t* list, int dispw, int disph)
+void rgz_profile_hwc(hwc_display_contents_1_t* list, int dispw, int disph)
 {
     if (!list)  /* A NULL composition list can occur */
         return;
@@ -1673,4 +1673,3 @@ int rgz_out(rgz_t *rgz, rgz_out_params_t *params)
         return -1;
     }
 }
-
-- 
cgit v1.2.3