← Back to branch summary

~ubuntu-branches/ubuntu/utopic/xserver-xorg-video-intel/utopic

« back to all changes in this revision

Viewing changes to src/sna/gen7_render.c

  • Committer: Package Import Robot
  • Author(s): Timo Aaltonen
  • Date: 2012-09-12 07:43:59 UTC
  • mfrom: (1.4.22)
  • Revision ID: package-import@ubuntu.com-20120912074359-i3h8ol6hoghbemoq
Tags: 2:2.20.7-0ubuntu1
Merge from unreleased debian git.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sna/gen7_render.c
994
994
}
995
995
 
996
996
inline static void
997
 
gen7_emit_pipe_invalidate(struct sna *sna, bool stall)
 
997
gen7_emit_pipe_invalidate(struct sna *sna)
998
998
{
999
999
        OUT_BATCH(GEN7_PIPE_CONTROL | (4 - 2));
1000
1000
        OUT_BATCH(GEN7_PIPE_CONTROL_WC_FLUSH |
1001
1001
                  GEN7_PIPE_CONTROL_TC_FLUSH |
1002
 
                  (stall ? GEN7_PIPE_CONTROL_CS_STALL : 0));
 
1002
                  GEN7_PIPE_CONTROL_CS_STALL);
1003
1003
        OUT_BATCH(0);
1004
1004
        OUT_BATCH(0);
1005
1005
}
1043
1043
        need_stall &= gen7_emit_drawing_rectangle(sna, op);
1044
1044
 
1045
1045
        if (kgem_bo_is_dirty(op->src.bo) || kgem_bo_is_dirty(op->mask.bo)) {
1046
 
                if (op->dst.bo == op->src.bo || op->dst.bo == op->mask.bo)
1047
 
                        need_stall = GEN7_BLEND(op->u.gen7.flags) != NO_BLEND;
1048
 
                gen7_emit_pipe_invalidate(sna, need_stall);
 
1046
                gen7_emit_pipe_invalidate(sna);
1049
1047
                kgem_clear_dirty(&sna->kgem);
1050
1048
                if (op->dst.bo->exec)
1051
1049
                        kgem_bo_mark_dirty(op->dst.bo);
1069
1067
        DBG(("%s: CA fixup (%d -> %d)\n", __FUNCTION__,
1070
1068
             sna->render.vertex_start, sna->render.vertex_index));
1071
1069
 
1072
 
        gen7_emit_pipe_invalidate(sna, true);
 
1070
        gen7_emit_pipe_invalidate(sna);
1073
1071
 
1074
1072
        gen7_emit_cc(sna, gen7_get_blend(PictOpAdd, true, op->dst.format));
1075
1073
        gen7_emit_wm(sna,
1401
1399
        v = sna->render.vertices + sna->render.vertex_used;
1402
1400
        sna->render.vertex_used += 9;
1403
1401
        assert(sna->render.vertex_used <= sna->render.vertex_size);
1404
 
        assert(!too_large(r->dst.x + r->width, r->dst.y + r->height));
 
1402
        assert(!too_large(op->dst.x + r->dst.x + r->width,
 
1403
                          op->dst.y + r->dst.y + r->height));
1405
1404
 
1406
1405
        dst.p.x = r->dst.x + r->width;
1407
1406
        dst.p.y = r->dst.y + r->height;
3338
3337
                prefer_blt_bo(sna, dst_bo));
3339
3338
}
3340
3339
 
3341
 
static inline bool
3342
 
overlaps(struct sna *sna,
3343
 
         struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
3344
 
         struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
3345
 
         const BoxRec *box, int n, BoxRec *extents)
 
3340
inline static void boxes_extents(const BoxRec *box, int n, BoxRec *extents)
3346
3341
{
3347
 
        if (src_bo != dst_bo)
3348
 
                return false;
3349
 
 
3350
3342
        *extents = box[0];
3351
3343
        while (--n) {
3352
3344
                box++;
3361
3353
                if (box->y2 > extents->y2)
3362
3354
                        extents->y2 = box->y2;
3363
3355
        }
3364
 
 
 
3356
}
 
3357
 
 
3358
static inline bool
 
3359
overlaps(struct sna *sna,
 
3360
         struct kgem_bo *src_bo, int16_t src_dx, int16_t src_dy,
 
3361
         struct kgem_bo *dst_bo, int16_t dst_dx, int16_t dst_dy,
 
3362
         const BoxRec *box, int n, BoxRec *extents)
 
3363
{
 
3364
        if (src_bo != dst_bo)
 
3365
                return false;
 
3366
 
 
3367
        boxes_extents(box, n, extents);
3365
3368
        return (extents->x2 + src_dx > extents->x1 + dst_dx &&
3366
3369
                extents->x1 + src_dx < extents->x2 + dst_dx &&
3367
3370
                extents->y2 + src_dy > extents->y1 + dst_dy &&
3742
3745
                return false;
3743
3746
        }
3744
3747
 
3745
 
        if (op <= PictOpSrc &&
3746
 
            (prefer_blt_fill(sna, dst_bo) ||
3747
 
             too_large(dst->drawable.width, dst->drawable.height) ||
3748
 
             !gen7_check_dst_format(format))) {
 
3748
        if (prefer_blt_fill(sna, dst_bo) || !gen7_check_dst_format(format)) {
3749
3749
                uint8_t alu = GXinvalid;
3750
3750
 
3751
 
                pixel = 0;
3752
 
                if (op == PictOpClear)
3753
 
                        alu = GXclear;
3754
 
                else if (sna_get_pixel_from_rgba(&pixel,
3755
 
                                                 color->red,
3756
 
                                                 color->green,
3757
 
                                                 color->blue,
3758
 
                                                 color->alpha,
3759
 
                                                 format))
3760
 
                        alu = GXcopy;
 
3751
                if (op <= PictOpSrc) {
 
3752
                        pixel = 0;
 
3753
                        if (op == PictOpClear)
 
3754
                                alu = GXclear;
 
3755
                        else if (sna_get_pixel_from_rgba(&pixel,
 
3756
                                                         color->red,
 
3757
                                                         color->green,
 
3758
                                                         color->blue,
 
3759
                                                         color->alpha,
 
3760
                                                         format))
 
3761
                                alu = GXcopy;
 
3762
                }
3761
3763
 
3762
3764
                if (alu != GXinvalid &&
3763
3765
                    sna_blt_fill_boxes(sna, alu,
3767
3769
 
3768
3770
                if (!gen7_check_dst_format(format))
3769
3771
                        return false;
3770
 
 
3771
 
                if (too_large(dst->drawable.width, dst->drawable.height))
3772
 
                        return sna_tiling_fill_boxes(sna, op, format, color,
3773
 
                                                     dst, dst_bo, box, n);
3774
3772
        }
3775
3773
 
3776
3774
        if (op == PictOpClear) {
3795
3793
        tmp.dst.bo = dst_bo;
3796
3794
        tmp.dst.x = tmp.dst.y = 0;
3797
3795
 
 
3796
        sna_render_composite_redirect_init(&tmp);
 
3797
        if (too_large(dst->drawable.width, dst->drawable.height)) {
 
3798
                BoxRec extents;
 
3799
 
 
3800
                boxes_extents(box, n, &extents);
 
3801
                if (!sna_render_composite_redirect(sna, &tmp,
 
3802
                                                   extents.x1, extents.y1,
 
3803
                                                   extents.x2 - extents.x1,
 
3804
                                                   extents.y2 - extents.y1))
 
3805
                        return sna_tiling_fill_boxes(sna, op, format, color,
 
3806
                                                     dst, dst_bo, box, n);
 
3807
        }
 
3808
 
3798
3809
        tmp.src.bo = sna_render_get_solid(sna, pixel);
3799
3810
        tmp.mask.bo = NULL;
3800
3811
 
3839
3850
 
3840
3851
        gen7_vertex_flush(sna);
3841
3852
        kgem_bo_destroy(&sna->kgem, tmp.src.bo);
 
3853
        sna_render_composite_redirect_done(sna, &tmp);
3842
3854
        return true;
3843
3855
}
3844
3856