← Back to branch summary

~ubuntu-branches/ubuntu/natty/mesa/natty-proposed

« back to all changes in this revision

Viewing changes to src/mesa/main/bufferobj.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Hooker, Robert Hooker, Christopher James Halse Rogers
  • Date: 2010-09-14 08:55:40 UTC
  • mfrom: (1.2.28 upstream)
  • Revision ID: james.westby@ubuntu.com-20100914085540-m4fpl0hdjlfd4jgz
Tags: 7.9~git20100909-0ubuntu1
https://launchpad.net/bugs/631413
https://launchpad.net/bugs/628930
https://launchpad.net/bugs/628727
https://launchpad.net/bugs/596292
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/630315
https://launchpad.net/bugs/613694
https://launchpad.net/bugs/599741
https://launchpad.net/bugs/578619
https://launchpad.net/bugs/626943
https://launchpad.net/bugs/610541
https://launchpad.net/bugs/601052
[ Robert Hooker ]
* New upstream git snapshot up to commit 94118fe2d4b1e5 (LP: #631413)
* New features include ATI HD5xxx series support in r600, and a vastly
  improved glsl compiler.
* Remove pre-generated .pc's, use the ones generated at build time
  instead.
* Remove all references to mesa-utils now that its no longer shipped
  with the mesa source.
* Disable the experimental ARB_fragment_shader option by default on
  i915, it exposes incomplete functionality that breaks KDE compositing
  among other things. It can be enabled via driconf still. (LP: #628930).

[ Christopher James Halse Rogers ]
* debian/patches/04_osmesa_version.diff:
  - Refresh for new upstream
* Bugs fixed in this release:
  - Fixes severe rendering corruption in Unity on radeon (LP: #628727,
    LP: #596292, LP: #599741, LP: #630315, LP: #613694, LP: #599741).
  - Also fixes rendering in gnome-shell (LP: #578619).
  - Flickering in OpenGL apps on radeon (LP: #626943, LP: #610541).
  - Provides preliminary support for new intel chips (LP: #601052).
* debian/rules:
  - Update configure flags to match upstream reshuffling.
  - Explicitly remove gallium DRI drivers that we don't want to ship.
* Update debian/gbp.conf for this Maverick-specific packaging
* libegl1-mesa-dri-x11,kms: There are no longer separate kms or x11 drivers
  for EGL, libegl1-mesa-drivers now contains a single driver that provides
  both backends.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/mesa/main/bufferobj.c
32
32
 
33
33
 
34
34
#include "glheader.h"
 
35
#include "enums.h"
35
36
#include "hash.h"
36
37
#include "imports.h"
37
38
#include "image.h"
46
47
/*#define BOUNDS_CHECK*/
47
48
 
48
49
 
49
 
#ifdef FEATURE_OES_mapbuffer
 
50
#if FEATURE_OES_mapbuffer
50
51
#define DEFAULT_ACCESS GL_MAP_WRITE_BIT
51
52
#else
52
53
#define DEFAULT_ACCESS (GL_MAP_READ_BIT | GL_MAP_WRITE_BIT)
82
83
         return &ctx->CopyWriteBuffer;
83
84
      }
84
85
      break;
 
86
#if FEATURE_EXT_transform_feedback
 
87
   case GL_TRANSFORM_FEEDBACK_BUFFER:
 
88
      if (ctx->Extensions.EXT_transform_feedback) {
 
89
         return &ctx->TransformFeedback.CurrentBuffer;
 
90
      }
 
91
      break;
 
92
#endif
85
93
   default:
86
94
      return NULL;
87
95
   }
582
590
 
583
591
   bindTarget = get_buffer_target(ctx, target);
584
592
   if (!bindTarget) {
585
 
      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)");
 
593
      _mesa_error(ctx, GL_INVALID_ENUM, "glBindBufferARB(target 0x%x)", target);
586
594
      return;
587
595
   }
588
596
 
1376
1384
 
1377
1385
   bufObj = get_buffer(ctx, target);
1378
1386
   if (!bufObj) {
1379
 
      _mesa_error(ctx, GL_INVALID_ENUM, "GetBufferParameterivARB(target)" );
 
1387
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(target)" );
1380
1388
      return;
1381
1389
   }
1382
1390
   if (!_mesa_is_bufferobj(bufObj)) {
1383
 
      _mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameterivARB" );
 
1391
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameterivARB" );
1384
1392
      return;
1385
1393
   }
1386
1394
 
1387
1395
   switch (pname) {
1388
1396
   case GL_BUFFER_SIZE_ARB:
1389
1397
      *params = (GLint) bufObj->Size;
1390
 
      break;
 
1398
      return;
1391
1399
   case GL_BUFFER_USAGE_ARB:
1392
1400
      *params = bufObj->Usage;
1393
 
      break;
 
1401
      return;
1394
1402
   case GL_BUFFER_ACCESS_ARB:
1395
1403
      *params = simplified_access_mode(bufObj->AccessFlags);
1396
 
      break;
 
1404
      return;
1397
1405
   case GL_BUFFER_MAPPED_ARB:
1398
1406
      *params = _mesa_bufferobj_mapped(bufObj);
1399
 
      break;
 
1407
      return;
 
1408
   case GL_BUFFER_ACCESS_FLAGS:
 
1409
      if (ctx->VersionMajor < 3)
 
1410
         goto invalid_pname;
 
1411
      *params = bufObj->AccessFlags;
 
1412
      return;
 
1413
   case GL_BUFFER_MAP_OFFSET:
 
1414
      if (ctx->VersionMajor < 3)
 
1415
         goto invalid_pname;
 
1416
      *params = (GLint) bufObj->Offset;
 
1417
      return;
 
1418
   case GL_BUFFER_MAP_LENGTH:
 
1419
      if (ctx->VersionMajor < 3)
 
1420
         goto invalid_pname;
 
1421
      *params = (GLint) bufObj->Length;
 
1422
      return;
1400
1423
   default:
1401
 
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname)");
1402
 
      return;
 
1424
      ; /* fall-through */
1403
1425
   }
 
1426
 
 
1427
invalid_pname:
 
1428
   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameterivARB(pname=%s)",
 
1429
               _mesa_lookup_enum_by_nr(pname));
1404
1430
}
1405
1431
 
1406
1432
 
1418
1444
 
1419
1445
   bufObj = get_buffer(ctx, target);
1420
1446
   if (!bufObj) {
1421
 
      _mesa_error(ctx, GL_INVALID_ENUM, "GetBufferParameteri64v(target)" );
 
1447
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(target)" );
1422
1448
      return;
1423
1449
   }
1424
1450
   if (!_mesa_is_bufferobj(bufObj)) {
1425
 
      _mesa_error(ctx, GL_INVALID_OPERATION, "GetBufferParameteri64v" );
 
1451
      _mesa_error(ctx, GL_INVALID_OPERATION, "glGetBufferParameteri64v" );
1426
1452
      return;
1427
1453
   }
1428
1454
 
1429
1455
   switch (pname) {
1430
1456
   case GL_BUFFER_SIZE_ARB:
1431
1457
      *params = bufObj->Size;
1432
 
      break;
 
1458
      return;
1433
1459
   case GL_BUFFER_USAGE_ARB:
1434
1460
      *params = bufObj->Usage;
1435
 
      break;
 
1461
      return;
1436
1462
   case GL_BUFFER_ACCESS_ARB:
1437
1463
      *params = simplified_access_mode(bufObj->AccessFlags);
1438
 
      break;
 
1464
      return;
 
1465
   case GL_BUFFER_ACCESS_FLAGS:
 
1466
      if (ctx->VersionMajor < 3)
 
1467
         goto invalid_pname;
 
1468
      *params = bufObj->AccessFlags;
 
1469
      return;
1439
1470
   case GL_BUFFER_MAPPED_ARB:
1440
1471
      *params = _mesa_bufferobj_mapped(bufObj);
1441
 
      break;
 
1472
      return;
 
1473
   case GL_BUFFER_MAP_OFFSET:
 
1474
      if (ctx->VersionMajor < 3)
 
1475
         goto invalid_pname;
 
1476
      *params = bufObj->Offset;
 
1477
      return;
 
1478
   case GL_BUFFER_MAP_LENGTH:
 
1479
      if (ctx->VersionMajor < 3)
 
1480
         goto invalid_pname;
 
1481
      *params = bufObj->Length;
 
1482
      return;
1442
1483
   default:
1443
 
      _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname)");
1444
 
      return;
 
1484
      ; /* fall-through */
1445
1485
   }
 
1486
 
 
1487
invalid_pname:
 
1488
   _mesa_error(ctx, GL_INVALID_ENUM, "glGetBufferParameteri64v(pname=%s)",
 
1489
               _mesa_lookup_enum_by_nr(pname));
1446
1490
}
1447
1491
 
1448
1492
 
1509
1553
 
1510
1554
   if (readOffset < 0) {
1511
1555
      _mesa_error(ctx, GL_INVALID_VALUE,
1512
 
                  "glCopyBuffserSubData(readOffset = %d)", readOffset);
 
1556
                  "glCopyBuffserSubData(readOffset = %d)", (int) readOffset);
1513
1557
      return;
1514
1558
   }
1515
1559
 
1516
1560
   if (writeOffset < 0) {
1517
1561
      _mesa_error(ctx, GL_INVALID_VALUE,
1518
 
                  "glCopyBuffserSubData(writeOffset = %d)", writeOffset);
 
1562
                  "glCopyBuffserSubData(writeOffset = %d)", (int) writeOffset);
1519
1563
      return;
1520
1564
   }
1521
1565
 
1522
1566
   if (readOffset + size > src->Size) {
1523
1567
      _mesa_error(ctx, GL_INVALID_VALUE,
1524
1568
                  "glCopyBuffserSubData(readOffset + size = %d)",
1525
 
                  readOffset, size);
 
1569
                  (int) (readOffset + size));
1526
1570
      return;
1527
1571
   }
1528
1572
 
1529
1573
   if (writeOffset + size > dst->Size) {
1530
1574
      _mesa_error(ctx, GL_INVALID_VALUE,
1531
1575
                  "glCopyBuffserSubData(writeOffset + size = %d)",
1532
 
                  writeOffset, size);
 
1576
                  (int) (writeOffset + size));
1533
1577
      return;
1534
1578
   }
1535
1579
 
1573
1617
 
1574
1618
   if (offset < 0) {
1575
1619
      _mesa_error(ctx, GL_INVALID_VALUE,
1576
 
                  "glMapBufferRange(offset = %ld)", offset);
 
1620
                  "glMapBufferRange(offset = %ld)", (long)offset);
1577
1621
      return NULL;
1578
1622
   }
1579
1623
 
1580
1624
   if (length < 0) {
1581
1625
      _mesa_error(ctx, GL_INVALID_VALUE,
1582
 
                  "glMapBufferRange(length = %ld)", length);
 
1626
                  "glMapBufferRange(length = %ld)", (long)length);
1583
1627
      return NULL;
1584
1628
   }
1585
1629
 
1664
1708
 
1665
1709
   if (offset < 0) {
1666
1710
      _mesa_error(ctx, GL_INVALID_VALUE,
1667
 
                  "glMapBufferRange(offset = %ld)", offset);
 
1711
                  "glMapBufferRange(offset = %ld)", (long)offset);
1668
1712
      return;
1669
1713
   }
1670
1714
 
1671
1715
   if (length < 0) {
1672
1716
      _mesa_error(ctx, GL_INVALID_VALUE,
1673
 
                  "glMapBufferRange(length = %ld)", length);
 
1717
                  "glMapBufferRange(length = %ld)", (long)length);
1674
1718
      return;
1675
1719
   }
1676
1720
 
1702
1746
 
1703
1747
   if (offset + length > bufObj->Length) {
1704
1748
      _mesa_error(ctx, GL_INVALID_VALUE,
1705
 
             "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",
1706
 
             offset, length, bufObj->Length);
 
1749
                  "glMapBufferRange(offset %ld + length %ld > mapped length %ld)",
 
1750
                  (long)offset, (long)length, (long)bufObj->Length);
1707
1751
      return;
1708
1752
   }
1709
1753
 
1880
1924
 
1881
1925
   bufObj->Purgeable = GL_FALSE;
1882
1926
 
1883
 
   retval = GL_RETAINED_APPLE;
 
1927
   retval = option;
1884
1928
   if (ctx->Driver.BufferObjectUnpurgeable)
1885
1929
      retval = ctx->Driver.BufferObjectUnpurgeable(ctx, bufObj, option);
1886
1930
 
1910
1954
 
1911
1955
   bufObj->Purgeable = GL_FALSE;
1912
1956
 
1913
 
   retval = GL_RETAINED_APPLE;
 
1957
   retval = option;
1914
1958
   if (ctx->Driver.RenderObjectUnpurgeable)
1915
1959
      retval = ctx->Driver.RenderObjectUnpurgeable(ctx, bufObj, option);
1916
1960
 
1917
 
   return option;
 
1961
   return retval;
1918
1962
}
1919
1963
 
1920
1964
 
1940
1984
 
1941
1985
   bufObj->Purgeable = GL_FALSE;
1942
1986
 
1943
 
   retval = GL_RETAINED_APPLE;
 
1987
   retval = option;
1944
1988
   if (ctx->Driver.TextureObjectUnpurgeable)
1945
1989
      retval = ctx->Driver.TextureObjectUnpurgeable(ctx, bufObj, option);
1946
1990