~ubuntu-branches/ubuntu/raring/xserver-xorg-video-intel/raring : revision 177

42

43

#include "brw/brw.h"

44

#include "gen7_render.h"

45

#include "gen4_vertex.h"

45

46

47

#define NO_COMPOSITE 0

47

48

#define NO_COMPOSITE_SPANS 0

1092

1093

state->last_primitive = sna->kgem.nbatch;

1093

1094

}

1094

1095

static void gen7_vertex_flush(struct sna *sna)

1096

{

1097

assert(sna->render_state.gen7.vertex_offset);

1098

1099

DBG(("%s[%x] = %d\n", __FUNCTION__,

1100

4*sna->render_state.gen7.vertex_offset,

1101

sna->render.vertex_index - sna->render.vertex_start));

1102

sna->kgem.batch[sna->render_state.gen7.vertex_offset] =

1103

sna->render.vertex_index - sna->render.vertex_start;

1104

sna->render_state.gen7.vertex_offset = 0;

1105

}

1106

1107

static int gen7_vertex_finish(struct sna *sna)

1108

{

1109

struct kgem_bo *bo;

1110

unsigned int i;

1111

1112

assert(sna->render.vertex_used);

1113

assert(sna->render.nvertex_reloc);

1114

1115

/* Note: we only need dword alignment (currently) */

1116

1117

bo = sna->render.vbo;

1118

if (bo) {

1119

if (sna->render_state.gen7.vertex_offset)

1120

gen7_vertex_flush(sna);

1121

1122

for (i = 0; i < sna->render.nvertex_reloc; i++) {

1123

DBG(("%s: reloc[%d] = %d\n", __FUNCTION__,

1124

i, sna->render.vertex_reloc[i]));

1125

1126

sna->kgem.batch[sna->render.vertex_reloc[i]] =

1127

kgem_add_reloc(&sna->kgem,

1128

sna->render.vertex_reloc[i], bo,

1129

I915_GEM_DOMAIN_VERTEX << 16,

1130

0);

1131

}

1132

1133

sna->render.nvertex_reloc = 0;

1134

sna->render.vertex_used = 0;

1135

sna->render.vertex_index = 0;

1136

sna->render.vbo = NULL;

1137

sna->render_state.gen7.vb_id = 0;

1138

1139

kgem_bo_destroy(&sna->kgem, bo);

1140

}

1141

1142

sna->render.vertices = NULL;

1143

sna->render.vbo = kgem_create_linear(&sna->kgem,

1144

256*1024, CREATE_GTT_MAP);

1145

if (sna->render.vbo)

1146

sna->render.vertices = kgem_bo_map(&sna->kgem, sna->render.vbo);

1147

if (sna->render.vertices == NULL) {

1148

if (sna->render.vbo)

1149

kgem_bo_destroy(&sna->kgem, sna->render.vbo);

1150

sna->render.vbo = NULL;

1151

return 0;

1152

}

1153

1154

kgem_bo_sync__cpu(&sna->kgem, sna->render.vbo);

1155

if (sna->render.vertex_used) {

1156

memcpy(sna->render.vertices,

1157

sna->render.vertex_data,

1158

sizeof(float)*sna->render.vertex_used);

1159

}

1160

sna->render.vertex_size = 64 * 1024 - 1;

1161

return sna->render.vertex_size - sna->render.vertex_used;

1162

}

1163

1164

static void gen7_vertex_close(struct sna *sna)

1165

{

1166

struct kgem_bo *bo, *free_bo = NULL;

1167

unsigned int i, delta = 0;

1168

1169

assert(sna->render_state.gen7.vertex_offset == 0);

1170

1171

if (!sna->render_state.gen7.vb_id)

1172

return;

1173

1174

DBG(("%s: used=%d, vbo active? %d\n",

1175

__FUNCTION__, sna->render.vertex_used, sna->render.vbo ? sna->render.vbo->handle : 0));

1176

1177

bo = sna->render.vbo;

1178

if (bo) {

1179

if (sna->render.vertex_size - sna->render.vertex_used < 64) {

1180

DBG(("%s: discarding vbo (full), handle=%d\n", __FUNCTION__, sna->render.vbo->handle));

1181

sna->render.vbo = NULL;

1182

sna->render.vertices = sna->render.vertex_data;

1183

sna->render.vertex_size = ARRAY_SIZE(sna->render.vertex_data);

1184

free_bo = bo;

1185

}

1186

} else {

1187

if (sna->kgem.nbatch + sna->render.vertex_used <= sna->kgem.surface) {

1188

DBG(("%s: copy to batch: %d @ %d\n", __FUNCTION__,

1189

sna->render.vertex_used, sna->kgem.nbatch));

1190

memcpy(sna->kgem.batch + sna->kgem.nbatch,

1191

sna->render.vertex_data,

1192

sna->render.vertex_used * 4);

1193

delta = sna->kgem.nbatch * 4;

1194

bo = NULL;

1195

sna->kgem.nbatch += sna->render.vertex_used;

1196

} else {

1197

bo = kgem_create_linear(&sna->kgem,

1198

4*sna->render.vertex_used, 0);

1199

if (bo && !kgem_bo_write(&sna->kgem, bo,

1200

sna->render.vertex_data,

1201

4*sna->render.vertex_used)) {

1202

kgem_bo_destroy(&sna->kgem, bo);

1203

bo = NULL;

1204

}

1205

DBG(("%s: new vbo: %d\n", __FUNCTION__,

1206

sna->render.vertex_used));

1207

free_bo = bo;

1208

}

1209

}

1210

1211

assert(sna->render.nvertex_reloc);

1212

for (i = 0; i < sna->render.nvertex_reloc; i++) {

1213

DBG(("%s: reloc[%d] = %d\n", __FUNCTION__,

1214

i, sna->render.vertex_reloc[i]));

1215

1216

sna->kgem.batch[sna->render.vertex_reloc[i]] =

1217

kgem_add_reloc(&sna->kgem,

1218

sna->render.vertex_reloc[i], bo,

1219

I915_GEM_DOMAIN_VERTEX << 16,

1220

delta);

1221

}

1222

sna->render.nvertex_reloc = 0;

1223

1224

if (sna->render.vbo == NULL) {

1225

sna->render.vertex_used = 0;

1226

sna->render.vertex_index = 0;

1227

assert(sna->render.vertices == sna->render.vertex_data);

1228

assert(sna->render.vertex_size == ARRAY_SIZE(sna->render.vertex_data));

1229

}

1230

1231

if (free_bo)

1232

kgem_bo_destroy(&sna->kgem, free_bo);

1233

}

1234

1235

1096

static void null_create(struct sna_static_stream *stream)

1236

1097

{

1237

1098

/* A bunch of zeros useful for legacy border color and depth-stencil */

1373

1234

if (sna->kgem.gen == 075)

1374

1235

ss[7] |= HSW_SURFACE_SWIZZLE(RED, GREEN, BLUE, ALPHA);

1375

1236

1376

kgem_bo_set_binding(bo, format, offset | is_scanout << 31);

1237

kgem_bo_set_binding(bo, format | is_scanout << 31, offset);

1377

1238

1378

1239

DBG(("[%x] bind bo(handle=%d, addr=%d), format=%d, width=%d, height=%d, pitch=%d, tiling=%d -> %s\n",

1379

1240

offset, bo->handle, ss[1],

1383

1244

return offset * sizeof(uint32_t);

1384

1245

}

1385

1246

1386

fastcall static void

1387

gen7_emit_composite_primitive_solid(struct sna *sna,

1388

const struct sna_composite_op *op,

1389

const struct sna_composite_rectangles *r)

1390

{

1391

float *v;

1392

union {

1393

struct sna_coordinate p;

1394

float f;

1395

} dst;

1396

1397

v = sna->render.vertices + sna->render.vertex_used;

1398

sna->render.vertex_used += 9;

1399

assert(sna->render.vertex_used <= sna->render.vertex_size);

1400

assert(!too_large(op->dst.x + r->dst.x + r->width,

1401

op->dst.y + r->dst.y + r->height));

1402

1403

dst.p.x = r->dst.x + r->width;

1404

dst.p.y = r->dst.y + r->height;

1405

v[0] = dst.f;

1406

dst.p.x = r->dst.x;

1407

v[3] = dst.f;

1408

dst.p.y = r->dst.y;

1409

v[6] = dst.f;

1410

1411

v[5] = v[2] = v[1] = 1.;

1412

v[8] = v[7] = v[4] = 0.;

1413

}

1414

1415

fastcall static void

1416

gen7_emit_composite_primitive_identity_source(struct sna *sna,

1417

const struct sna_composite_op *op,

1418

const struct sna_composite_rectangles *r)

1419

{

1420

union {

1421

struct sna_coordinate p;

1422

float f;

1423

} dst;

1424

float *v;

1425

1426

v = sna->render.vertices + sna->render.vertex_used;

1427

sna->render.vertex_used += 9;

1428

1429

dst.p.x = r->dst.x + r->width;

1430

dst.p.y = r->dst.y + r->height;

1431

v[0] = dst.f;

1432

dst.p.x = r->dst.x;

1433

v[3] = dst.f;

1434

dst.p.y = r->dst.y;

1435

v[6] = dst.f;

1436

1437

v[7] = v[4] = (r->src.x + op->src.offset[0]) * op->src.scale[0];

1438

v[1] = v[4] + r->width * op->src.scale[0];

1439

1440

v[8] = (r->src.y + op->src.offset[1]) * op->src.scale[1];

1441

v[5] = v[2] = v[8] + r->height * op->src.scale[1];

1442

}

1443

1444

fastcall static void

1445

gen7_emit_composite_primitive_simple_source(struct sna *sna,

1446

const struct sna_composite_op *op,

1447

const struct sna_composite_rectangles *r)

1448

{

1449

float *v;

1450

union {

1451

struct sna_coordinate p;

1452

float f;

1453

} dst;

1454

1455

float xx = op->src.transform->matrix[0][0];

1456

float x0 = op->src.transform->matrix[0][2];

1457

float yy = op->src.transform->matrix[1][1];

1458

float y0 = op->src.transform->matrix[1][2];

1459

float sx = op->src.scale[0];

1460

float sy = op->src.scale[1];

1461

int16_t tx = op->src.offset[0];

1462

int16_t ty = op->src.offset[1];

1463

1464

v = sna->render.vertices + sna->render.vertex_used;

1465

sna->render.vertex_used += 3*3;

1466

1467

dst.p.x = r->dst.x + r->width;

1468

dst.p.y = r->dst.y + r->height;

1469

v[0] = dst.f;

1470

v[1] = ((r->src.x + r->width + tx) * xx + x0) * sx;

1471

v[5] = v[2] = ((r->src.y + r->height + ty) * yy + y0) * sy;

1472

1473

dst.p.x = r->dst.x;

1474

v[3] = dst.f;

1475

v[7] = v[4] = ((r->src.x + tx) * xx + x0) * sx;

1476

1477

dst.p.y = r->dst.y;

1478

v[6] = dst.f;

1479

v[8] = ((r->src.y + ty) * yy + y0) * sy;

1480

}

1481

1482

fastcall static void

1483

gen7_emit_composite_primitive_affine_source(struct sna *sna,

1484

const struct sna_composite_op *op,

1485

const struct sna_composite_rectangles *r)

1486

{

1487

union {

1488

struct sna_coordinate p;

1489

float f;

1490

} dst;

1491

float *v;

1492

1493

v = sna->render.vertices + sna->render.vertex_used;

1494

sna->render.vertex_used += 9;

1495

1496

dst.p.x = r->dst.x + r->width;

1497

dst.p.y = r->dst.y + r->height;

1498

v[0] = dst.f;

1499

_sna_get_transformed_coordinates(op->src.offset[0] + r->src.x + r->width,

1500

op->src.offset[1] + r->src.y + r->height,

1501

op->src.transform,

1502

&v[1], &v[2]);

1503

v[1] *= op->src.scale[0];

1504

v[2] *= op->src.scale[1];

1505

1506

dst.p.x = r->dst.x;

1507

v[3] = dst.f;

1508

_sna_get_transformed_coordinates(op->src.offset[0] + r->src.x,

1509

op->src.offset[1] + r->src.y + r->height,

1510

op->src.transform,

1511

&v[4], &v[5]);

1512

v[4] *= op->src.scale[0];

1513

v[5] *= op->src.scale[1];

1514

1515

dst.p.y = r->dst.y;

1516

v[6] = dst.f;

1517

_sna_get_transformed_coordinates(op->src.offset[0] + r->src.x,

1518

op->src.offset[1] + r->src.y,

1519

op->src.transform,

1520

&v[7], &v[8]);

1521

v[7] *= op->src.scale[0];

1522

v[8] *= op->src.scale[1];

1523

}

1524

1525

fastcall static void

1526

gen7_emit_composite_primitive_identity_mask(struct sna *sna,

1527

const struct sna_composite_op *op,

1528

const struct sna_composite_rectangles *r)

1529

{

1530

union {

1531

struct sna_coordinate p;

1532

float f;

1533

} dst;

1534

float msk_x, msk_y;

1535

float w, h;

1536

float *v;

1537

1538

msk_x = r->mask.x + op->mask.offset[0];

1539

msk_y = r->mask.y + op->mask.offset[1];

1540

w = r->width;

1541

h = r->height;

1542

1543

v = sna->render.vertices + sna->render.vertex_used;

1544

sna->render.vertex_used += 15;

1545

1546

dst.p.x = r->dst.x + r->width;

1547

dst.p.y = r->dst.y + r->height;

1548

v[0] = dst.f;

1549

v[3] = (msk_x + w) * op->mask.scale[0];

1550

v[9] = v[4] = (msk_y + h) * op->mask.scale[1];

1551

1552

dst.p.x = r->dst.x;

1553

v[5] = dst.f;

1554

v[13] = v[8] = msk_x * op->mask.scale[0];

1555

1556

dst.p.y = r->dst.y;

1557

v[10] = dst.f;

1558

v[14] = msk_y * op->mask.scale[1];

1559

1560

v[7] = v[2] = v[1] = 1;

1561

v[12] = v[11] = v[6] = 0;

1562

}

1563

1564

fastcall static void

1565

gen7_emit_composite_primitive_identity_source_mask(struct sna *sna,

1566

const struct sna_composite_op *op,

1567

const struct sna_composite_rectangles *r)

1568

{

1569

union {

1570

struct sna_coordinate p;

1571

float f;

1572

} dst;

1573

float src_x, src_y;

1574

float msk_x, msk_y;

1575

float w, h;

1576

float *v;

1577

1578

src_x = r->src.x + op->src.offset[0];

1579

src_y = r->src.y + op->src.offset[1];

1580

msk_x = r->mask.x + op->mask.offset[0];

1581

msk_y = r->mask.y + op->mask.offset[1];

1582

w = r->width;

1583

h = r->height;

1584

1585

v = sna->render.vertices + sna->render.vertex_used;

1586

sna->render.vertex_used += 15;

1587

1588

dst.p.x = r->dst.x + r->width;

1589

dst.p.y = r->dst.y + r->height;

1590

v[0] = dst.f;

1591

v[1] = (src_x + w) * op->src.scale[0];

1592

v[2] = (src_y + h) * op->src.scale[1];

1593

v[3] = (msk_x + w) * op->mask.scale[0];

1594

v[4] = (msk_y + h) * op->mask.scale[1];

1595

1596

dst.p.x = r->dst.x;

1597

v[5] = dst.f;

1598

v[6] = src_x * op->src.scale[0];

1599

v[7] = v[2];

1600

v[8] = msk_x * op->mask.scale[0];

1601

v[9] = v[4];

1602

1603

dst.p.y = r->dst.y;

1604

v[10] = dst.f;

1605

v[11] = v[6];

1606

v[12] = src_y * op->src.scale[1];

1607

v[13] = v[8];

1608

v[14] = msk_y * op->mask.scale[1];

1609

}

1610

1611

inline static void

1612

gen7_emit_composite_texcoord(struct sna *sna,

1613

const struct sna_composite_channel *channel,

1614

int16_t x, int16_t y)

1615

{

1616

x += channel->offset[0];

1617

y += channel->offset[1];

1618

1619

if (channel->is_affine) {

1620

float s, t;

1621

1622

sna_get_transformed_coordinates(x, y,

1623

channel->transform,

1624

&s, &t);

1625

OUT_VERTEX_F(s * channel->scale[0]);

1626

OUT_VERTEX_F(t * channel->scale[1]);

1627

} else {

1628

float s, t, w;

1629

1630

sna_get_transformed_coordinates_3d(x, y,

1631

channel->transform,

1632

&s, &t, &w);

1633

OUT_VERTEX_F(s * channel->scale[0]);

1634

OUT_VERTEX_F(t * channel->scale[1]);

1635

OUT_VERTEX_F(w);

1636

}

1637

}

1638

1639

static void

1640

gen7_emit_composite_vertex(struct sna *sna,

1641

const struct sna_composite_op *op,

1642

int16_t srcX, int16_t srcY,

1643

int16_t mskX, int16_t mskY,

1644

int16_t dstX, int16_t dstY)

1645

{

1646

OUT_VERTEX(dstX, dstY);

1647

gen7_emit_composite_texcoord(sna, &op->src, srcX, srcY);

1648

gen7_emit_composite_texcoord(sna, &op->mask, mskX, mskY);

1649

}

1650

1651

fastcall static void

1652

gen7_emit_composite_primitive(struct sna *sna,

1653

const struct sna_composite_op *op,

1654

const struct sna_composite_rectangles *r)

1655

{

1656

gen7_emit_composite_vertex(sna, op,

1657

r->src.x + r->width, r->src.y + r->height,

1658

r->mask.x + r->width, r->mask.y + r->height,

1659

r->dst.x + r->width, r->dst.y + r->height);

1660

gen7_emit_composite_vertex(sna, op,

1661

r->src.x, r->src.y + r->height,

1662

r->mask.x, r->mask.y + r->height,

1663

r->dst.x, r->dst.y + r->height);

1664

gen7_emit_composite_vertex(sna, op,

1665

r->src.x, r->src.y,

1666

r->mask.x, r->mask.y,

1667

r->dst.x, r->dst.y);

1668

}

1669

1670

1247

static void gen7_emit_vertex_buffer(struct sna *sna,

1671

1248

const struct sna_composite_op *op)

1672

1249

{

1682

1259

OUT_BATCH(~0); /* max address: disabled */

1683

1260

OUT_BATCH(0);

1684

1261

1685

sna->render_state.gen7.vb_id |= 1 << id;

1262

sna->render.vb_id |= 1 << id;

1686

1263

}

1687

1264

1688

1265

static void gen7_emit_primitive(struct sna *sna)

1689

1266

{

1690

1267

if (sna->kgem.nbatch == sna->render_state.gen7.last_primitive) {

1691

sna->render_state.gen7.vertex_offset = sna->kgem.nbatch - 5;

1268

sna->render.vertex_offset = sna->kgem.nbatch - 5;

1692

1269

return;

1693

1270

}

1694

1271

1695

1272

OUT_BATCH(GEN7_3DPRIMITIVE | (7- 2));

1696

1273

OUT_BATCH(GEN7_3DPRIMITIVE_VERTEX_SEQUENTIAL | _3DPRIM_RECTLIST);

1697

sna->render_state.gen7.vertex_offset = sna->kgem.nbatch;

1274

sna->render.vertex_offset = sna->kgem.nbatch;

1698

1275

OUT_BATCH(0); /* vertex count, to be filled in later */

1699

1276

OUT_BATCH(sna->render.vertex_index);

1700

1277

OUT_BATCH(1); /* single instance */

1712

1289

int ndwords;

1713

1290

1714

1291

ndwords = op->need_magic_ca_pass ? 60 : 6;

1715

if ((sna->render_state.gen7.vb_id & id) == 0)

1292

if ((sna->render.vb_id & id) == 0)

1716

1293

ndwords += 5;

1717

1294

if (!kgem_check_batch(&sna->kgem, ndwords))

1718

1295

return false;

1719

1296

1720

if ((sna->render_state.gen7.vb_id & id) == 0)

1297

if ((sna->render.vb_id & id) == 0)

1721

1298

gen7_emit_vertex_buffer(sna, op);

1722

1299

1723

1300

gen7_emit_primitive(sna);

1737

1314

if (op->need_magic_ca_pass && sna->render.vbo)

1738

1315

return 0;

1739

1316

1740

return gen7_vertex_finish(sna);

1317

return gen4_vertex_finish(sna);

1741

1318

}

1742

1319

1743

1320

inline static int gen7_get_rectangles(struct sna *sna,

1757

1334

goto flush;

1758

1335

}

1759

1336

1760

if (unlikely(sna->render_state.gen7.vertex_offset == 0 &&

1337

if (unlikely(sna->render.vertex_offset == 0 &&

1761

1338

!gen7_rectangle_begin(sna, op)))

1762

1339

goto flush;

1763

1340

1769

1346

return want;

1770

1347

1771

1348

flush:

1772

if (sna->render_state.gen7.vertex_offset) {

1773

gen7_vertex_flush(sna);

1349

if (sna->render.vertex_offset) {

1350

gen4_vertex_flush(sna);

1774

1351

gen7_magic_ca_pass(sna, op);

1775

1352

}

1776

1353

_kgem_submit(&sna->kgem);

1795

1372

return table;

1796

1373

}

1797

1374

1798

static uint32_t

1799

gen7_choose_composite_vertex_buffer(const struct sna_composite_op *op)

1800

{

1801

int id = 2 + !op->is_affine;

1802

if (op->mask.bo)

1803

id |= id << 2;

1804

assert(id > 0 && id < 16);

1805

return id;

1806

}

1807

1808

1375

static void

1809

1376

gen7_get_batch(struct sna *sna, const struct sna_composite_op *op)

1810

1377

{

1871

1438

{

1872

1439

if (op->floats_per_vertex != sna->render_state.gen7.floats_per_vertex) {

1873

1440

if (sna->render.vertex_size - sna->render.vertex_used < 2*op->floats_per_rect)

1874

gen7_vertex_finish(sna);

1441

gen4_vertex_finish(sna);

1875

1442

1876

1443

DBG(("aligning vertex: was %d, now %d floats per vertex, %d->%d\n",

1877

1444

sna->render_state.gen7.floats_per_vertex,

2088

1655

RegionPtr dstRegion,

2089

1656

short src_w, short src_h,

2090

1657

short drw_w, short drw_h,

1658

short dx, short dy,

2091

1659

PixmapPtr pixmap)

2092

1660

{

2093

1661

struct sna_composite_op tmp;

2094

int nbox, dxo, dyo, pix_xoff, pix_yoff;

1662

int nbox, pix_xoff, pix_yoff;

2095

1663

float src_scale_x, src_scale_y;

2096

1664

struct sna_pixmap *priv;

2097

1665

unsigned filter;

2159

1727

pix_yoff = 0;

2160

1728

#endif

2161

1729

2162

dxo = dstRegion->extents.x1;

2163

dyo = dstRegion->extents.y1;

2164

2165

1730

/* Use normalized texture coordinates */

2166

1731

src_scale_x = ((float)src_w / frame->width) / (float)drw_w;

2167

1732

src_scale_y = ((float)src_h / frame->height) / (float)drw_h;

2179

1744

gen7_get_rectangles(sna, &tmp, 1, gen7_emit_video_state);

2180

1745

2181

1746

OUT_VERTEX(r.x2, r.y2);

2182

OUT_VERTEX_F((box->x2 - dxo) * src_scale_x);

2183

OUT_VERTEX_F((box->y2 - dyo) * src_scale_y);

1747

OUT_VERTEX_F((box->x2 - dx) * src_scale_x);

1748

OUT_VERTEX_F((box->y2 - dy) * src_scale_y);

2184

1749

2185

1750

OUT_VERTEX(r.x1, r.y2);

2186

OUT_VERTEX_F((box->x1 - dxo) * src_scale_x);

2187

OUT_VERTEX_F((box->y2 - dyo) * src_scale_y);

1751

OUT_VERTEX_F((box->x1 - dx) * src_scale_x);

1752

OUT_VERTEX_F((box->y2 - dy) * src_scale_y);

2188

1753

2189

1754

OUT_VERTEX(r.x1, r.y1);

2190

OUT_VERTEX_F((box->x1 - dxo) * src_scale_x);

2191

OUT_VERTEX_F((box->y1 - dyo) * src_scale_y);

1755

OUT_VERTEX_F((box->x1 - dx) * src_scale_x);

1756

OUT_VERTEX_F((box->y1 - dy) * src_scale_y);

2192

1757

2193

1758

if (!DAMAGE_IS_ALL(priv->gpu_damage)) {

2194

1759

sna_damage_add_box(&priv->gpu_damage, &r);

2198

1763

}

2199

1764

priv->clear = false;

2200

1765

2201

gen7_vertex_flush(sna);

1766

gen4_vertex_flush(sna);

2202

1767

return true;

2203

1768

}

2204

1769

2446

2011

static void gen7_render_composite_done(struct sna *sna,

2447

2012

const struct sna_composite_op *op)

2448

2013

{

2449

if (sna->render_state.gen7.vertex_offset) {

2450

gen7_vertex_flush(sna);

2014

if (sna->render.vertex_offset) {

2015

gen4_vertex_flush(sna);

2451

2016

gen7_magic_ca_pass(sna, op);

2452

2017

}

2453

2018

2509

2074

2510

2075

inline static bool can_switch_to_blt(struct sna *sna)

2511

2076

{

2512

if (sna->kgem.ring == KGEM_BLT)

2077

if (sna->kgem.ring != KGEM_RENDER)

2513

2078

return true;

2514

2079

2515

2080

if (NO_RING_SWITCH)

2518

2083

if (!sna->kgem.has_semaphores)

2519

2084

return false;

2520

2085

2521

return (sna->kgem.mode == KGEM_NONE ||

2522

kgem_ring_is_idle(&sna->kgem, KGEM_BLT));

2086

return kgem_ring_is_idle(&sna->kgem, KGEM_BLT);

2523

2087

}

2524

2088

2525

2089

static inline bool untiled_tlb_miss(struct kgem_bo *bo)

2527

2091

return bo->tiling == I915_TILING_NONE && bo->pitch >= 4096;

2528

2092

}

2529

2093

2530

static bool prefer_blt_bo(struct sna *sna, struct kgem_bo *bo)

2094

static int prefer_blt_bo(struct sna *sna, struct kgem_bo *bo)

2531

2095

{

2532

return untiled_tlb_miss(bo) && bo->pitch < MAXSHORT;

2096

if (bo->rq)

2097

return RQ_IS_BLT(bo->rq) ? 1 : -1;

2098

2099

return bo->tiling == I915_TILING_NONE;

2533

2100

}

2534

2101

2535

2102

inline static bool prefer_blt_ring(struct sna *sna)

2785

2352

if (sna->kgem.ring == KGEM_BLT)

2786

2353

return true;

2787

2354

2355

if (untiled_tlb_miss(tmp->dst.bo) ||

2356

untiled_tlb_miss(tmp->src.bo))

2357

return true;

2358

2788

2359

if (!prefer_blt_ring(sna))

2789

2360

return false;

2790

2361

2791

return (prefer_blt_bo(sna, tmp->dst.bo) ||

2792

prefer_blt_bo(sna, tmp->src.bo));

2362

return (prefer_blt_bo(sna, tmp->dst.bo) >= 0 &&

2363

prefer_blt_bo(sna, tmp->src.bo) >= 0);

2793

2364

}

2794

2365

2795

2366

static bool

2870

2441

tmp->mask.filter = SAMPLER_FILTER_NEAREST;

2871

2442

tmp->mask.repeat = SAMPLER_EXTEND_NONE;

2872

2443

2873

tmp->prim_emit = gen7_emit_composite_primitive;

2874

2444

if (mask) {

2875

2445

if (mask->componentAlpha && PICT_FORMAT_RGB(mask->format)) {

2876

2446

tmp->has_component_alpha = true;

2910

2480

}

2911

2481

2912

2482

tmp->is_affine &= tmp->mask.is_affine;

2913

2914

if (tmp->src.transform == NULL && tmp->mask.transform == NULL) {

2915

if (tmp->src.is_solid)

2916

tmp->prim_emit = gen7_emit_composite_primitive_identity_mask;

2917

else

2918

tmp->prim_emit = gen7_emit_composite_primitive_identity_source_mask;

2919

}

2920

2921

tmp->floats_per_vertex = 5 + 2 * !tmp->is_affine;

2922

} else {

2923

if (tmp->src.is_solid) {

2924

tmp->prim_emit = gen7_emit_composite_primitive_solid;

2925

if (tmp->src.is_opaque && op == PictOpOver)

2926

tmp->op = PictOpSrc;

2927

} else if (tmp->src.transform == NULL)

2928

tmp->prim_emit = gen7_emit_composite_primitive_identity_source;

2929

else if (tmp->src.is_affine) {

2930

if (tmp->src.transform->matrix[0][1] == 0 &&

2931

tmp->src.transform->matrix[1][0] == 0) {

2932

tmp->src.scale[0] /= tmp->src.transform->matrix[2][2];

2933

tmp->src.scale[1] /= tmp->src.transform->matrix[2][2];

2934

tmp->prim_emit = gen7_emit_composite_primitive_simple_source;

2935

} else

2936

tmp->prim_emit = gen7_emit_composite_primitive_affine_source;

2937

}

2938

2939

tmp->floats_per_vertex = 3 + !tmp->is_affine;

2940

2483

}

2941

tmp->floats_per_rect = 3 * tmp->floats_per_vertex;

2484

2485

gen4_choose_composite_emitter(tmp);

2942

2486

2943

2487

tmp->u.gen7.flags =

2944

2488

GEN7_SET_FLAGS(SAMPLER_OFFSET(tmp->src.filter,

2952

2496

tmp->mask.bo != NULL,

2953

2497

tmp->has_component_alpha,

2954

2498

tmp->is_affine),

2955

gen7_choose_composite_vertex_buffer(tmp));

2499

gen4_choose_composite_vertex_buffer(tmp));

2956

2500

2957

2501

tmp->blt = gen7_render_composite_blt;

2958

2502

tmp->box = gen7_render_composite_box;

2988

2532

}

2989

2533

2990

2534

#if !NO_COMPOSITE_SPANS

2991

inline static void

2992

gen7_emit_composite_texcoord_affine(struct sna *sna,

2993

const struct sna_composite_channel *channel,

2994

int16_t x, int16_t y)

2995

{

2996

float t[2];

2997

2998

sna_get_transformed_coordinates(x + channel->offset[0],

2999

y + channel->offset[1],

3000

channel->transform,

3001

&t[0], &t[1]);

3002

OUT_VERTEX_F(t[0] * channel->scale[0]);

3003

OUT_VERTEX_F(t[1] * channel->scale[1]);

3004

}

3005

3006

inline static void

3007

gen7_emit_composite_spans_vertex(struct sna *sna,

3008

const struct sna_composite_spans_op *op,

3009

int16_t x, int16_t y)

3010

{

3011

OUT_VERTEX(x, y);

3012

gen7_emit_composite_texcoord(sna, &op->base.src, x, y);

3013

}

3014

3015

fastcall static void

3016

gen7_emit_composite_spans_primitive(struct sna *sna,

3017

const struct sna_composite_spans_op *op,

3018

const BoxRec *box,

3019

float opacity)

3020

{

3021

gen7_emit_composite_spans_vertex(sna, op, box->x2, box->y2);

3022

OUT_VERTEX_F(opacity);

3023

3024

gen7_emit_composite_spans_vertex(sna, op, box->x1, box->y2);

3025

OUT_VERTEX_F(opacity);

3026

3027

gen7_emit_composite_spans_vertex(sna, op, box->x1, box->y1);

3028

OUT_VERTEX_F(opacity);

3029

}

3030

3031

fastcall static void

3032

gen7_emit_composite_spans_solid(struct sna *sna,

3033

const struct sna_composite_spans_op *op,

3034

const BoxRec *box,

3035

float opacity)

3036

{

3037

OUT_VERTEX(box->x2, box->y2);

3038

OUT_VERTEX_F(1); OUT_VERTEX_F(1);

3039

OUT_VERTEX_F(opacity);

3040

3041

OUT_VERTEX(box->x1, box->y2);

3042

OUT_VERTEX_F(0); OUT_VERTEX_F(1);

3043

OUT_VERTEX_F(opacity);

3044

3045

OUT_VERTEX(box->x1, box->y1);

3046

OUT_VERTEX_F(0); OUT_VERTEX_F(0);

3047

OUT_VERTEX_F(opacity);

3048

}

3049

3050

fastcall static void

3051

gen7_emit_composite_spans_identity(struct sna *sna,

3052

const struct sna_composite_spans_op *op,

3053

const BoxRec *box,

3054

float opacity)

3055

{

3056

float *v;

3057

union {

3058

struct sna_coordinate p;

3059

float f;

3060

} dst;

3061

3062

float sx = op->base.src.scale[0];

3063

float sy = op->base.src.scale[1];

3064

int16_t tx = op->base.src.offset[0];

3065

int16_t ty = op->base.src.offset[1];

3066

3067

v = sna->render.vertices + sna->render.vertex_used;

3068

sna->render.vertex_used += 3*4;

3069

assert(sna->render.vertex_used <= sna->render.vertex_size);

3070

3071

dst.p.x = box->x2;

3072

dst.p.y = box->y2;

3073

v[0] = dst.f;

3074

v[1] = (box->x2 + tx) * sx;

3075

v[6] = v[2] = (box->y2 + ty) * sy;

3076

3077

dst.p.x = box->x1;

3078

v[4] = dst.f;

3079

v[9] = v[5] = (box->x1 + tx) * sx;

3080

3081

dst.p.y = box->y1;

3082

v[8] = dst.f;

3083

v[10] = (box->y1 + ty) * sy;

3084

3085

v[11] = v[7] = v[3] = opacity;

3086

}

3087

3088

fastcall static void

3089

gen7_emit_composite_spans_simple(struct sna *sna,

3090

const struct sna_composite_spans_op *op,

3091

const BoxRec *box,

3092

float opacity)

3093

{

3094

float *v;

3095

union {

3096

struct sna_coordinate p;

3097

float f;

3098

} dst;

3099

3100

float xx = op->base.src.transform->matrix[0][0];

3101

float x0 = op->base.src.transform->matrix[0][2];

3102

float yy = op->base.src.transform->matrix[1][1];

3103

float y0 = op->base.src.transform->matrix[1][2];

3104

float sx = op->base.src.scale[0];

3105

float sy = op->base.src.scale[1];

3106

int16_t tx = op->base.src.offset[0];

3107

int16_t ty = op->base.src.offset[1];

3108

3109

v = sna->render.vertices + sna->render.vertex_used;

3110

sna->render.vertex_used += 3*4;

3111

assert(sna->render.vertex_used <= sna->render.vertex_size);

3112

3113

dst.p.x = box->x2;

3114

dst.p.y = box->y2;

3115

v[0] = dst.f;

3116

v[1] = ((box->x2 + tx) * xx + x0) * sx;

3117

v[6] = v[2] = ((box->y2 + ty) * yy + y0) * sy;

3118

3119

dst.p.x = box->x1;

3120

v[4] = dst.f;

3121

v[9] = v[5] = ((box->x1 + tx) * xx + x0) * sx;

3122

3123

dst.p.y = box->y1;

3124

v[8] = dst.f;

3125

v[10] = ((box->y1 + ty) * yy + y0) * sy;

3126

3127

v[11] = v[7] = v[3] = opacity;

3128

}

3129

3130

fastcall static void

3131

gen7_emit_composite_spans_affine(struct sna *sna,

3132

const struct sna_composite_spans_op *op,

3133

const BoxRec *box,

3134

float opacity)

3135

{

3136

OUT_VERTEX(box->x2, box->y2);

3137

gen7_emit_composite_texcoord_affine(sna, &op->base.src,

3138

box->x2, box->y2);

3139

OUT_VERTEX_F(opacity);

3140

3141

OUT_VERTEX(box->x1, box->y2);

3142

gen7_emit_composite_texcoord_affine(sna, &op->base.src,

3143

box->x1, box->y2);

3144

OUT_VERTEX_F(opacity);

3145

3146

OUT_VERTEX(box->x1, box->y1);

3147

gen7_emit_composite_texcoord_affine(sna, &op->base.src,

3148

box->x1, box->y1);

3149

OUT_VERTEX_F(opacity);

3150

}

3151

3152

2535

fastcall static void

3153

2536

gen7_render_composite_spans_box(struct sna *sna,

3154

2537

const struct sna_composite_spans_op *op,

3201

2584

gen7_render_composite_spans_done(struct sna *sna,

3202

2585

const struct sna_composite_spans_op *op)

3203

2586

{

3204

if (sna->render_state.gen7.vertex_offset)

3205

gen7_vertex_flush(sna);

2587

if (sna->render.vertex_offset)

2588

gen4_vertex_flush(sna);

3206

2589

3207

2590

DBG(("%s()\n", __FUNCTION__));

3208

2591

3283

2666

tmp->base.is_affine = tmp->base.src.is_affine;

3284

2667

tmp->base.need_magic_ca_pass = false;

3285

2668

3286

tmp->prim_emit = gen7_emit_composite_spans_primitive;

3287

if (tmp->base.src.is_solid) {

3288

tmp->prim_emit = gen7_emit_composite_spans_solid;

3289

} else if (tmp->base.src.transform == NULL) {

3290

tmp->prim_emit = gen7_emit_composite_spans_identity;

3291

} else if (tmp->base.is_affine) {

3292

if (tmp->base.src.transform->matrix[0][1] == 0 &&

3293

tmp->base.src.transform->matrix[1][0] == 0) {

3294

tmp->base.src.scale[0] /= tmp->base.src.transform->matrix[2][2];

3295

tmp->base.src.scale[1] /= tmp->base.src.transform->matrix[2][2];

3296

tmp->prim_emit = gen7_emit_composite_spans_simple;

3297

} else

3298

tmp->prim_emit = gen7_emit_composite_spans_affine;

3299

}

3300

tmp->base.floats_per_vertex = 4 + !tmp->base.is_affine;

3301

tmp->base.floats_per_rect = 3 * tmp->base.floats_per_vertex;

2669

gen4_choose_spans_emitter(tmp);

3302

2670

3303

2671

tmp->base.u.gen7.flags =

3304

2672

GEN7_SET_FLAGS(SAMPLER_OFFSET(tmp->base.src.filter,

3307

2675

SAMPLER_EXTEND_PAD),

3308

2676

gen7_get_blend(tmp->base.op, false, tmp->base.dst.format),

3309

2677

GEN7_WM_KERNEL_OPACITY | !tmp->base.is_affine,

3310

1 << 2 | (2+!tmp->base.is_affine));

2678

gen4_choose_spans_vertex_buffer(&tmp->base));

3311

2679

3312

2680

tmp->box = gen7_render_composite_spans_box;

3313

2681

tmp->boxes = gen7_render_composite_spans_boxes;

3382

2750

if (src_bo == dst_bo && can_switch_to_blt(sna))

3383

2751

return true;

3384

2752

3385

return ((flags & COPY_LAST && sna->kgem.ring != KGEM_RENDER) ||

3386

prefer_blt_bo(sna, src_bo) ||

3387

prefer_blt_bo(sna, dst_bo));

2753

if ((flags & COPY_LAST && sna->kgem.ring != KGEM_RENDER))

2754

return true;

2755

2756

if (untiled_tlb_miss(src_bo) ||

2757

untiled_tlb_miss(dst_bo))

2758

return true;

2759

2760

return (prefer_blt_bo(sna, src_bo) >= 0 &&

2761

prefer_blt_bo(sna, dst_bo) >= 0);

3388

2762

}

3389

2763

3390

2764

inline static void boxes_extents(const BoxRec *box, int n, BoxRec *extents)

3607

2981

} while (--n_this_time);

3608

2982

} while (n);

3609

2983

3610

gen7_vertex_flush(sna);

2984

gen4_vertex_flush(sna);

3611

2985

sna_render_composite_redirect_done(sna, &tmp);

3612

2986

if (tmp.src.bo != src_bo)

3613

2987

kgem_bo_destroy(&sna->kgem, tmp.src.bo);

3652

3026

static void

3653

3027

gen7_render_copy_done(struct sna *sna, const struct sna_copy_op *op)

3654

3028

{

3655

if (sna->render_state.gen7.vertex_offset)

3656

gen7_vertex_flush(sna);

3029

if (sna->render.vertex_offset)

3030

gen4_vertex_flush(sna);

3657

3031

}

3658

3032

3659

3033

static bool

3771

3145

static inline bool prefer_blt_fill(struct sna *sna,

3772

3146

struct kgem_bo *bo)

3773

3147

{

3774

return prefer_blt_ring(sna) || untiled_tlb_miss(bo);

3148

if (untiled_tlb_miss(bo))

3149

return true;

3150

3151

return (can_switch_to_blt(sna) ||

3152

prefer_blt_ring(sna) ||

3153

prefer_blt_bo(sna, bo) >= 0);

3775

3154

}

3776

3155

3777

3156

static bool

3866

3245

3867

3246

tmp.u.gen7.flags = FILL_FLAGS(op, format);

3868

3247

3248

kgem_set_mode(&sna->kgem, KGEM_RENDER, dst_bo);

3869

3249

if (!kgem_check_bo(&sna->kgem, dst_bo, NULL)) {

3870

3250

kgem_submit(&sna->kgem);

3871

3251

assert(kgem_check_bo(&sna->kgem, dst_bo, NULL));

3899

3279

} while (--n_this_time);

3900

3280

} while (n);

3901

3281

3902

gen7_vertex_flush(sna);

3282

gen4_vertex_flush(sna);

3903

3283

kgem_bo_destroy(&sna->kgem, tmp.src.bo);

3904

3284

sna_render_composite_redirect_done(sna, &tmp);

3905

3285

return true;

3990

3370

static void

3991

3371

gen7_render_fill_op_done(struct sna *sna, const struct sna_fill_op *op)

3992

3372

{

3993

if (sna->render_state.gen7.vertex_offset)

3994

gen7_vertex_flush(sna);

3373

if (sna->render.vertex_offset)

3374

gen4_vertex_flush(sna);

3995

3375

kgem_bo_destroy(&sna->kgem, op->base.src.bo);

3996

3376

}

3997

3377

4039

3419

4040

3420

op->base.u.gen7.flags = FILL_FLAGS_NOBLEND;

4041

3421

3422

kgem_set_mode(&sna->kgem, KGEM_RENDER, dst_bo);

4042

3423

if (!kgem_check_bo(&sna->kgem, dst_bo, NULL)) {

4043

3424

kgem_submit(&sna->kgem);

4044

3425

assert(kgem_check_bo(&sna->kgem, dst_bo, NULL));

4116

3497

4117

3498

tmp.u.gen7.flags = FILL_FLAGS_NOBLEND;

4118

3499

3500

kgem_set_mode(&sna->kgem, KGEM_RENDER, bo);

4119

3501

if (!kgem_check_bo(&sna->kgem, bo, NULL)) {

4120

3502

_kgem_submit(&sna->kgem);

4121

3503

assert(kgem_check_bo(&sna->kgem, bo, NULL));

4139

3521

v[7] = v[2] = v[3] = 1;

4140

3522

v[6] = v[10] = v[11] = 0;

4141

3523

4142

gen7_vertex_flush(sna);

3524

gen4_vertex_flush(sna);

4143

3525

kgem_bo_destroy(&sna->kgem, tmp.src.bo);

4144

3526

4145

3527

return true;

4196

3578

4197

3579

tmp.u.gen7.flags = FILL_FLAGS_NOBLEND;

4198

3580

3581

kgem_set_mode(&sna->kgem, KGEM_RENDER, bo);

4199

3582

if (!kgem_check_bo(&sna->kgem, bo, NULL)) {

4200

3583

_kgem_submit(&sna->kgem);

4201

3584

assert(kgem_check_bo(&sna->kgem, bo, NULL));

4218

3601

v[7] = v[2] = v[3] = 1;

4219

3602

v[6] = v[10] = v[11] = 0;

4220

3603

4221

gen7_vertex_flush(sna);

3604

gen4_vertex_flush(sna);

4222

3605

kgem_bo_destroy(&sna->kgem, tmp.src.bo);

4223

3606

4224

3607

return true;

4226

3609

4227

3610

static void gen7_render_flush(struct sna *sna)

4228

3611

{

4229

gen7_vertex_close(sna);

3612

gen4_vertex_close(sna);

3613

3614

assert(sna->render.vb_id == 0);

3615

assert(sna->render.vertex_offset == 0);

4230

3616

}

4231

3617

4232

3618

static void

4233

3619

gen7_render_context_switch(struct kgem *kgem,

4234

3620

int new_mode)

4235

3621

{

4236

if (!new_mode)

4237

return;

4238

4239

if (kgem->mode) {

3622

if (kgem->nbatch) {

4240

3623

DBG(("%s: switch rings %d -> %d\n",

4241

3624

__FUNCTION__, kgem->mode, new_mode));

4242

kgem_submit(kgem);

3625

_kgem_submit(kgem);

4243

3626

}

4244

3627

4245

3628

kgem->ring = new_mode;

4282

3665

{

4283

3666

sna->render_state.gen7.emit_flush = false;

4284

3667

sna->render_state.gen7.needs_invariant = true;

4285

sna->render_state.gen7.vb_id = 0;

4286

3668

sna->render_state.gen7.ve_id = 3 << 2;

4287

3669

sna->render_state.gen7.last_primitive = -1;

4288

3670