← Back to branch summary

~ubuntu-branches/debian/jessie/xserver-xorg-video-intel/jessie

« back to all changes in this revision

Viewing changes to src/sna/sna_blt.c

  • Committer: Package Import Robot
  • Author(s): Julien Cristau
  • Date: 2012-05-26 12:38:07 UTC
  • mfrom: (26.1.14 sid)
  • Revision ID: package-import@ubuntu.com-20120526123807-esybcmtb8h417v2r
Tags: 2:2.19.0-1
New upstream release.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/sna/sna_blt.c
118
118
{
119
119
        struct kgem *kgem = &sna->kgem;
120
120
 
 
121
        assert(kgem_bo_can_blt (kgem, bo));
121
122
        assert(bo->tiling != I915_TILING_Y);
122
123
        blt->bo[0] = bo;
123
124
 
127
128
                blt->cmd |= BLT_DST_TILED;
128
129
                blt->br13 >>= 2;
129
130
        }
130
 
        assert(blt->br13 < MAXSHORT);
 
131
        assert(blt->br13 <= MAXSHORT);
131
132
 
132
133
        if (alu == GXclear)
133
134
                pixel = 0;
150
151
        blt->bpp = bpp;
151
152
 
152
153
        kgem_set_mode(kgem, KGEM_BLT);
153
 
        if (!kgem_check_bo_fenced(kgem, bo, NULL) ||
 
154
        if (!kgem_check_bo_fenced(kgem, bo) ||
154
155
            !kgem_check_batch(kgem, 12)) {
155
156
                _kgem_submit(kgem);
156
 
                assert(kgem_check_bo_fenced(kgem, bo, NULL));
 
157
                assert(kgem_check_bo_fenced(kgem, bo));
157
158
                _kgem_set_mode(kgem, KGEM_BLT);
158
159
        }
159
160
 
258
259
{
259
260
        struct kgem *kgem = &sna->kgem;
260
261
 
 
262
        assert(kgem_bo_can_blt (kgem, src));
 
263
        assert(kgem_bo_can_blt (kgem, dst));
 
264
 
261
265
        blt->bo[0] = src;
262
266
        blt->bo[1] = dst;
263
267
 
270
274
                blt->cmd |= BLT_SRC_TILED;
271
275
                blt->pitch[0] >>= 2;
272
276
        }
273
 
        assert(blt->pitch[0] < MAXSHORT);
 
277
        assert(blt->pitch[0] <= MAXSHORT);
274
278
 
275
279
        blt->pitch[1] = dst->pitch;
276
280
        if (kgem->gen >= 40 && dst->tiling) {
277
281
                blt->cmd |= BLT_DST_TILED;
278
282
                blt->pitch[1] >>= 2;
279
283
        }
280
 
        assert(blt->pitch[1] < MAXSHORT);
 
284
        assert(blt->pitch[1] <= MAXSHORT);
281
285
 
282
286
        blt->overwrites = alu == GXcopy || alu == GXclear || alu == GXset;
283
287
        blt->br13 = (copy_ROP[alu] << 16) | blt->pitch[1];
289
293
        }
290
294
 
291
295
        kgem_set_mode(kgem, KGEM_BLT);
292
 
        if (!kgem_check_bo_fenced(kgem, src, dst, NULL)) {
 
296
        if (!kgem_check_many_bo_fenced(kgem, src, dst, NULL)) {
293
297
                _kgem_submit(kgem);
294
 
                if (!kgem_check_bo_fenced(kgem, src, dst, NULL))
 
298
                if (!kgem_check_many_bo_fenced(kgem, src, dst, NULL))
295
299
                        return FALSE;
296
300
                _kgem_set_mode(kgem, KGEM_BLT);
297
301
        }
308
312
{
309
313
        struct kgem *kgem = &sna->kgem;
310
314
 
 
315
        assert(kgem_bo_can_blt (kgem, src));
 
316
        assert(kgem_bo_can_blt (kgem, dst));
 
317
 
311
318
        blt->bo[0] = src;
312
319
        blt->bo[1] = dst;
313
320
 
317
324
                blt->cmd |= BLT_SRC_TILED;
318
325
                blt->pitch[0] >>= 2;
319
326
        }
320
 
        assert(blt->pitch[0] < MAXSHORT);
 
327
        assert(blt->pitch[0] <= MAXSHORT);
321
328
 
322
329
        blt->pitch[1] = dst->pitch;
323
330
        if (kgem->gen >= 40 && dst->tiling) {
324
331
                blt->cmd |= BLT_DST_TILED;
325
332
                blt->pitch[1] >>= 2;
326
333
        }
327
 
        assert(blt->pitch[1] < MAXSHORT);
 
334
        assert(blt->pitch[1] <= MAXSHORT);
328
335
 
329
336
        blt->overwrites = 1;
330
337
        blt->br13 = (0xfc << 16) | blt->pitch[1];
338
345
        blt->pixel = alpha;
339
346
 
340
347
        kgem_set_mode(kgem, KGEM_BLT);
341
 
        if (!kgem_check_bo_fenced(kgem, src, dst, NULL)) {
 
348
        if (!kgem_check_many_bo_fenced(kgem, src, dst, NULL)) {
342
349
                _kgem_submit(kgem);
343
 
                if (!kgem_check_bo_fenced(kgem, src, dst, NULL))
 
350
                if (!kgem_check_many_bo_fenced(kgem, src, dst, NULL))
344
351
                        return FALSE;
345
352
                _kgem_set_mode(kgem, KGEM_BLT);
346
353
        }
469
476
        kgem->nbatch += 8;
470
477
}
471
478
 
472
 
static Bool
473
 
get_rgba_from_pixel(uint32_t pixel,
474
 
                    uint16_t *red,
475
 
                    uint16_t *green,
476
 
                    uint16_t *blue,
477
 
                    uint16_t *alpha,
478
 
                    uint32_t format)
 
479
Bool
 
480
sna_get_rgba_from_pixel(uint32_t pixel,
 
481
                        uint16_t *red,
 
482
                        uint16_t *green,
 
483
                        uint16_t *blue,
 
484
                        uint16_t *alpha,
 
485
                        uint32_t format)
479
486
{
480
487
        int rbits, bbits, gbits, abits;
481
488
        int rshift, bshift, gshift, ashift;
600
607
        return TRUE;
601
608
}
602
609
 
603
 
static uint32_t
604
 
color_convert(uint32_t pixel,
605
 
              uint32_t src_format,
606
 
              uint32_t dst_format)
607
 
{
608
 
        DBG(("%s: src=%08x [%08x]\n", __FUNCTION__, pixel, src_format));
609
 
 
610
 
        if (src_format != dst_format) {
611
 
                uint16_t red, green, blue, alpha;
612
 
 
613
 
                if (!get_rgba_from_pixel(pixel,
614
 
                                         &red, &green, &blue, &alpha,
615
 
                                         src_format))
616
 
                        return 0;
617
 
 
618
 
                if (!sna_get_pixel_from_rgba(&pixel,
619
 
                                             red, green, blue, alpha,
620
 
                                             dst_format))
621
 
                        return 0;
622
 
        }
623
 
 
624
 
        DBG(("%s: dst=%08x [%08x]\n", __FUNCTION__, pixel, dst_format));
625
 
        return pixel;
626
 
}
627
 
 
628
610
uint32_t
629
611
sna_rgba_for_color(uint32_t color, int depth)
630
612
{
631
613
        return color_convert(color, sna_format_for_depth(depth), PICT_a8r8g8b8);
632
614
}
633
615
 
 
616
uint32_t
 
617
sna_rgba_to_color(uint32_t rgba, uint32_t format)
 
618
{
 
619
        return color_convert(rgba, PICT_a8r8g8b8, format);
 
620
}
 
621
 
634
622
static uint32_t
635
623
get_pixel(PicturePtr picture)
636
624
{
667
655
        }
668
656
 
669
657
        if (picture->pDrawable) {
670
 
                if (picture->pDrawable->width == 1 &&
 
658
                if (picture->pDrawable->width  == 1 &&
671
659
                    picture->pDrawable->height == 1 &&
672
660
                    picture->repeat)
673
661
                        return TRUE;
907
895
{
908
896
        DBG(("%s\n", __FUNCTION__));
909
897
 
910
 
        op->blt   = blt_composite_fill;
 
898
        op->blt = blt_composite_fill;
911
899
        if (op->dst.x|op->dst.y) {
912
900
                op->box   = blt_composite_fill_box;
913
901
                op->boxes = blt_composite_fill_boxes;
915
903
                op->box   = blt_composite_fill_box_no_offset;
916
904
                op->boxes = blt_composite_fill_boxes_no_offset;
917
905
        }
918
 
        op->done  = nop_done;
 
906
        op->done = nop_done;
919
907
 
920
908
        return sna_blt_fill_init(sna, &op->u.blt,
921
909
                                 op->dst.bo,
930
918
{
931
919
        DBG(("%s\n", __FUNCTION__));
932
920
 
933
 
        op->blt   = blt_composite_fill;
 
921
        op->blt = blt_composite_fill;
934
922
        if (op->dst.x|op->dst.y) {
935
923
                op->box   = blt_composite_fill_box;
936
924
                op->boxes = blt_composite_fill_boxes;
938
926
                op->box   = blt_composite_fill_box_no_offset;
939
927
                op->boxes = blt_composite_fill_boxes_no_offset;
940
928
        }
941
 
        op->done  = nop_done;
 
929
        op->done = nop_done;
942
930
 
943
931
        return sna_blt_fill_init(sna, &op->u.blt, op->dst.bo,
944
932
                                 op->dst.pixmap->drawable.bitsPerPixel,
1115
1103
        if (!kgem_bo_can_blt(&sna->kgem, priv->gpu_bo))
1116
1104
                return FALSE;
1117
1105
 
1118
 
        if (!kgem_check_bo_fenced(&sna->kgem, op->dst.bo, priv->gpu_bo, NULL)) {
 
1106
        if (!kgem_check_many_bo_fenced(&sna->kgem, op->dst.bo, priv->gpu_bo, NULL)) {
1119
1107
                _kgem_submit(&sna->kgem);
1120
 
                if (!kgem_check_bo_fenced(&sna->kgem,
1121
 
                                          op->dst.bo, priv->gpu_bo, NULL))
 
1108
                if (!kgem_check_many_bo_fenced(&sna->kgem,
 
1109
                                               op->dst.bo, priv->gpu_bo, NULL))
1122
1110
                        return FALSE;
1123
1111
                _kgem_set_mode(&sna->kgem, KGEM_BLT);
1124
1112
        }
1126
1114
        DBG(("%s\n", __FUNCTION__));
1127
1115
 
1128
1116
        if (sna->kgem.gen >= 60)
1129
 
                op->done  = gen6_blt_copy_done;
 
1117
                op->done = gen6_blt_copy_done;
1130
1118
        else
1131
 
                op->done  = nop_done;
 
1119
                op->done = nop_done;
1132
1120
 
1133
1121
        if (alpha_fixup) {
1134
1122
                op->blt   = blt_composite_copy_with_alpha;
1153
1141
        }
1154
1142
}
1155
1143
 
1156
 
static void blt_vmap_done(struct sna *sna, const struct sna_composite_op *op)
1157
 
{
1158
 
        struct kgem_bo *bo = (struct kgem_bo *)op->u.blt.src_pixmap;
1159
 
 
1160
 
        if (bo)
1161
 
                kgem_bo_destroy(&sna->kgem, bo);
1162
 
}
1163
 
 
1164
1144
fastcall static void
1165
1145
blt_put_composite(struct sna *sna,
1166
1146
                  const struct sna_composite_op *op,
1395
1375
                uint32_t alpha_fixup)
1396
1376
{
1397
1377
        PixmapPtr src = op->u.blt.src_pixmap;
1398
 
        struct sna_pixmap *priv = sna_pixmap_attach(src);
1399
 
        struct kgem_bo *src_bo = NULL;
1400
 
        struct kgem_bo *free_bo = NULL;
 
1378
        struct sna_pixmap *priv;
 
1379
        struct kgem_bo *src_bo;
1401
1380
 
1402
1381
        DBG(("%s\n", __FUNCTION__));
1403
1382
 
1404
 
        if (priv) {
 
1383
        op->done = nop_done;
 
1384
 
 
1385
        src_bo = NULL;
 
1386
        priv = sna_pixmap(src);
 
1387
        if (priv)
1405
1388
                src_bo = priv->cpu_bo;
1406
 
        } else {
1407
 
                src_bo = kgem_create_map(&sna->kgem,
1408
 
                                         src->devPrivate.ptr,
1409
 
                                         pixmap_size(src),
1410
 
                                         0);
1411
 
                free_bo = src_bo;
1412
 
        }
1413
1389
        if (src_bo) {
1414
 
                op->u.blt.src_pixmap = (void *)free_bo;
1415
 
                op->done = blt_vmap_done;
1416
 
 
1417
 
                src_bo->pitch = src->devKind;
1418
1390
                if (alpha_fixup) {
1419
1391
                        op->blt   = blt_composite_copy_with_alpha;
1420
1392
                        op->box   = blt_composite_copy_box_with_alpha;
1435
1407
                                                 GXcopy);
1436
1408
                }
1437
1409
        } else {
 
1410
                if (!sna_pixmap_move_to_cpu(src, MOVE_READ))
 
1411
                        return FALSE;
 
1412
 
 
1413
                assert(src->devKind);
 
1414
                assert(src->devPrivate.ptr);
 
1415
 
1438
1416
                if (alpha_fixup)
1439
1417
                        return FALSE; /* XXX */
1440
1418
 
1441
 
                if (!sna_pixmap_move_to_cpu(src, MOVE_READ))
1442
 
                        return FALSE;
1443
 
 
1444
1419
                if (alpha_fixup) {
1445
1420
                        op->u.blt.pixel = alpha_fixup;
1446
1421
                        op->blt   = blt_put_composite_with_alpha;
1451
1426
                        op->box   = blt_put_composite_box;
1452
1427
                        op->boxes = blt_put_composite_boxes;
1453
1428
                }
1454
 
                op->done  = nop_done;
1455
1429
        }
1456
1430
 
1457
1431
        return TRUE;
1557
1531
        struct sna_pixmap *priv;
1558
1532
        int16_t tx, ty;
1559
1533
        uint32_t alpha_fixup;
 
1534
        bool was_clear;
1560
1535
        Bool ret;
1561
1536
 
1562
1537
#if DEBUG_NO_BLT || NO_BLT_COMPOSITE
1577
1552
                return FALSE;
1578
1553
        }
1579
1554
 
 
1555
        was_clear = sna_drawable_is_clear(dst->pDrawable);
1580
1556
        tmp->dst.pixmap = get_drawable_pixmap(dst->pDrawable);
1581
1557
        priv = sna_pixmap_move_to_gpu(tmp->dst.pixmap, MOVE_WRITE | MOVE_READ);
1582
1558
        if (priv == NULL) {
1601
1577
        if (width && height)
1602
1578
                reduce_damage(tmp, dst_x, dst_y, width, height);
1603
1579
 
1604
 
        if (!kgem_check_bo_fenced(&sna->kgem, priv->gpu_bo, NULL)) {
 
1580
        if (!kgem_check_bo_fenced(&sna->kgem, priv->gpu_bo)) {
1605
1581
                _kgem_submit(&sna->kgem);
1606
 
                assert(kgem_check_bo_fenced(&sna->kgem, priv->gpu_bo, NULL));
 
1582
                assert(kgem_check_bo_fenced(&sna->kgem, priv->gpu_bo));
1607
1583
                _kgem_set_mode(&sna->kgem, KGEM_BLT);
1608
1584
        }
1609
1585
 
1610
 
        if (op == PictOpClear)
 
1586
        if (op == PictOpClear) {
 
1587
clear:
 
1588
                if (was_clear)
 
1589
                        return TRUE;
1611
1590
                return prepare_blt_clear(sna, tmp);
 
1591
        }
1612
1592
 
1613
1593
        if (is_solid(src)) {
1614
1594
                if (op == PictOpOver && is_opaque_solid(src))
1615
1595
                        op = PictOpSrc;
1616
1596
                if (op == PictOpAdd && is_white(src))
1617
1597
                        op = PictOpSrc;
 
1598
                if (was_clear && (op == PictOpAdd || op == PictOpOver))
 
1599
                        op = PictOpSrc;
1618
1600
                if (op == PictOpOutReverse && is_opaque_solid(src))
1619
 
                        return prepare_blt_clear(sna, tmp);
 
1601
                        goto clear;
1620
1602
 
1621
1603
                if (op != PictOpSrc) {
1622
1604
                        DBG(("%s: unsuported op [%d] for blitting\n",
1837
1819
        uint32_t br13, cmd, *b;
1838
1820
        bool overwrites;
1839
1821
 
 
1822
        assert(kgem_bo_can_blt (kgem, bo));
 
1823
 
1840
1824
        DBG(("%s: box=((%d, %d), (%d, %d))\n", __FUNCTION__,
1841
1825
             box->x1, box->y1, box->x2, box->y2));
1842
1826
 
1849
1833
                cmd |= BLT_DST_TILED;
1850
1834
                br13 >>= 2;
1851
1835
        }
1852
 
        assert(br13 < MAXSHORT);
 
1836
        assert(br13 <= MAXSHORT);
1853
1837
 
1854
1838
        br13 |= fill_ROP[alu] << 16;
1855
1839
        switch (bpp) {
1900
1884
        kgem_set_mode(kgem, KGEM_BLT);
1901
1885
        if (!kgem_check_batch(kgem, 6) ||
1902
1886
            !kgem_check_reloc(kgem, 1) ||
1903
 
            !kgem_check_bo_fenced(kgem, bo, NULL)) {
 
1887
            !kgem_check_bo_fenced(kgem, bo)) {
1904
1888
                _kgem_submit(kgem);
1905
 
                assert(kgem_check_bo_fenced(&sna->kgem, bo, NULL));
 
1889
                assert(kgem_check_bo_fenced(&sna->kgem, bo));
1906
1890
                _kgem_set_mode(kgem, KGEM_BLT);
1907
1891
        }
1908
1892
 
1962
1946
                cmd |= 1 << 11;
1963
1947
                br13 >>= 2;
1964
1948
        }
1965
 
        assert(br13 < MAXSHORT);
 
1949
        assert(br13 <= MAXSHORT);
1966
1950
 
1967
1951
        br13 |= 1<<31 | fill_ROP[alu] << 16;
1968
1952
        switch (bpp) {
1973
1957
        }
1974
1958
 
1975
1959
        kgem_set_mode(kgem, KGEM_BLT);
1976
 
        if (!kgem_check_bo_fenced(kgem, bo, NULL) ||
 
1960
        if (!kgem_check_bo_fenced(kgem, bo) ||
1977
1961
            !kgem_check_batch(kgem, 12)) {
1978
1962
                _kgem_submit(kgem);
1979
 
                assert(kgem_check_bo_fenced(&sna->kgem, bo, NULL));
 
1963
                assert(kgem_check_bo_fenced(&sna->kgem, bo));
1980
1964
                _kgem_set_mode(kgem, KGEM_BLT);
1981
1965
        }
1982
1966
 
2113
2097
                cmd |= BLT_DST_TILED;
2114
2098
                br13 >>= 2;
2115
2099
        }
2116
 
        assert(br13 < MAXSHORT);
 
2100
        assert(br13 <= MAXSHORT);
2117
2101
 
2118
2102
        br13 |= copy_ROP[alu] << 16;
2119
2103
        switch (bpp) {
2138
2122
        kgem_set_mode(kgem, KGEM_BLT);
2139
2123
        if (!kgem_check_batch(kgem, 8) ||
2140
2124
            !kgem_check_reloc(kgem, 2) ||
2141
 
            !kgem_check_bo_fenced(kgem, dst_bo, src_bo, NULL)) {
 
2125
            !kgem_check_many_bo_fenced(kgem, dst_bo, src_bo, NULL)) {
2142
2126
                _kgem_submit(kgem);
2143
 
                if (!kgem_check_bo_fenced(kgem, dst_bo, src_bo, NULL))
 
2127
                if (!kgem_check_many_bo_fenced(kgem, dst_bo, src_bo, NULL))
2144
2128
                        return sna_tiling_blt_copy_boxes(sna, alu,
2145
2129
                                                         src_bo, src_dx, src_dy,
2146
2130
                                                         dst_bo, dst_dx, dst_dy,