From 5af067fba423027e357456625d59847a6ba8e005 Mon Sep 17 00:00:00 2001
From: Alexander von Gluck IV <kallisti5@unixzen.com>
Date: Wed, 11 Apr 2012 14:22:44 -0500
Subject: [PATCH] radeon_hd: Style fix in new ring code

* Thanks Axel for catching this.
---
 .../accelerants/radeon_hd/ringqueue.cpp       | 74 +++++++++----------
 src/add-ons/accelerants/radeon_hd/ringqueue.h | 20 ++---
 2 files changed, 47 insertions(+), 47 deletions(-)

diff --git a/src/add-ons/accelerants/radeon_hd/ringqueue.cpp b/src/add-ons/accelerants/radeon_hd/ringqueue.cpp
index 03f20f4bb3..dda63f45f8 100644
--- a/src/add-ons/accelerants/radeon_hd/ringqueue.cpp
+++ b/src/add-ons/accelerants/radeon_hd/ringqueue.cpp
@@ -45,46 +45,46 @@ compute_order(unsigned long size)
 
 RingQueue::RingQueue(size_t sizeBytes, uint32 queueType)
 	:
-	_queueType(queueType),
-	_readPtr(0),
-	_writePtr(0)
+	fQueueType(queueType),
+	fReadPtr(0),
+	fWritePtr(0)
 {
 	TRACE("%s: Requested %d bytes for %s RingQueue.\n", __func__, sizeBytes,
-		queueName[_queueType]);
+		queueName[fQueueType]);
 
 	size_t renderQueueSize = compute_order(sizeBytes / 8);
-	_size = (1 << (renderQueueSize + 1)) * 4;
-	_writeBytesAvail = _size;
-	_alignMask = 16 - 1;
+	fSize = (1 << (renderQueueSize + 1)) * 4;
+	fWriteBytesAvail = fSize;
+	fAlignMask = 16 - 1;
 
-	TRACE("%s: Allocating %d bytes for %s RingQueue.\n", __func__, _size,
-		queueName[_queueType]);
+	TRACE("%s: Allocating %d bytes for %s RingQueue.\n", __func__, fSize,
+		queueName[fQueueType]);
 
 	// Allocate buffer memory
-	_data = (unsigned char*)malloc(_size);
+	fData = (unsigned char*)malloc(fSize);
 	// Clear buffer
-	memset(_data, 0, _size);
+	memset(fData, 0, fSize);
 }
 
 
 RingQueue::~RingQueue()
 {
-	TRACE("%s: Closing %s RingQueue.\n", __func__, queueName[_queueType]);
-	free(_data);
+	TRACE("%s: Closing %s RingQueue.\n", __func__, queueName[fQueueType]);
+	free(fData);
 }
 
 
 status_t
 RingQueue::Empty()
 {
-	TRACE("%s: Clearing %s RingQueue\n", __func__, queueName[_queueType]);
+	TRACE("%s: Clearing %s RingQueue\n", __func__, queueName[fQueueType]);
 	// Clear buffer
-	memset(_data, 0, _size);
+	memset(fData, 0, fSize);
 
 	// Reset counters
-	_readPtr = 0;
-	_writePtr = 0;
-	_writeBytesAvail = _size;
+	fReadPtr = 0;
+	fWritePtr = 0;
+	fWriteBytesAvail = fSize;
 	return B_OK;
 }
 
@@ -93,26 +93,26 @@ size_t
 RingQueue::Read(unsigned char* dataPtr, size_t bytes)
 {
 	// If there is no data or nothing to read, return 0 bytes
-	if (dataPtr == 0 || bytes <= 0 || _writeBytesAvail == _size)
+	if (dataPtr == 0 || bytes <= 0 || fWriteBytesAvail == fSize)
 		return 0;
 
-	size_t readBytesAvail = _size - _writeBytesAvail;
+	size_t readBytesAvail = fSize - fWriteBytesAvail;
 
 	// Set a high threshold of total available bytes available.
 	if (bytes > readBytesAvail)
 		bytes = readBytesAvail;
 
 	// Keep track of position and pull needed data
-	if (bytes > _size - _readPtr) {
-		size_t len = _size - _readPtr;
-		memcpy(dataPtr, _data + _readPtr, len);
-		memcpy(dataPtr + len, _data, bytes - len);
+	if (bytes > fSize - fReadPtr) {
+		size_t len = fSize - fReadPtr;
+		memcpy(dataPtr, fData + fReadPtr, len);
+		memcpy(dataPtr + len, fData, bytes - len);
 	} else {
-		memcpy(dataPtr, _data + _readPtr, bytes);
+		memcpy(dataPtr, fData + fReadPtr, bytes);
 	}
 
-	_readPtr = (_readPtr + bytes) % _size;
-	_writeBytesAvail += bytes;
+	fReadPtr = (fReadPtr + bytes) % fSize;
+	fWriteBytesAvail += bytes;
 
 	return bytes;
 }
@@ -122,23 +122,23 @@ size_t
 RingQueue::Write(unsigned char* dataPtr, size_t bytes)
 {
 	// If there is no data, or no room available, 0 bytes written.
-	if (dataPtr == 0 || bytes <= 0 || _writeBytesAvail == 0)
+	if (dataPtr == 0 || bytes <= 0 || fWriteBytesAvail == 0)
 		return 0;
 
 	// Set a high threshold of the number of bytes available.
-	if (bytes > _writeBytesAvail)
-		bytes = _writeBytesAvail;
+	if (bytes > fWriteBytesAvail)
+		bytes = fWriteBytesAvail;
 
 	// Keep track of position and push needed data
-	if (bytes > _size - _writePtr) {
-		size_t len = _size - _writePtr;
-		memcpy(_data + _writePtr, dataPtr, len);
-		memcpy(_data, dataPtr + len, bytes - len);
+	if (bytes > fSize - fWritePtr) {
+		size_t len = fSize - fWritePtr;
+		memcpy(fData + fWritePtr, dataPtr, len);
+		memcpy(fData, dataPtr + len, bytes - len);
 	} else
-		memcpy(_data + _writePtr, dataPtr, bytes);
+		memcpy(fData + fWritePtr, dataPtr, bytes);
 
-	_writePtr = (_writePtr + bytes) % _size;
-	_writeBytesAvail -= bytes;
+	fWritePtr = (fWritePtr + bytes) % fSize;
+	fWriteBytesAvail -= bytes;
 
 	return bytes;
 }
diff --git a/src/add-ons/accelerants/radeon_hd/ringqueue.h b/src/add-ons/accelerants/radeon_hd/ringqueue.h
index c9dc9de965..66bd122e6b 100644
--- a/src/add-ons/accelerants/radeon_hd/ringqueue.h
+++ b/src/add-ons/accelerants/radeon_hd/ringqueue.h
@@ -30,19 +30,19 @@ public:
 			size_t			Write(unsigned char* data, size_t bytes);
 			status_t		Empty();
 
-			size_t			GetSize() {return _size;};
-			size_t			GetWriteAvail() {return _writeBytesAvail;}
-			size_t			GetReadAvail() {return _size - _writeBytesAvail;}
+			size_t			GetSize() {return fSize;};
+			size_t			GetWriteAvail() {return fWriteBytesAvail;}
+			size_t			GetReadAvail() {return fSize - fWriteBytesAvail;}
 private:
-			uint32			_queueType;
+			uint32			fQueueType;
 
-			unsigned char*	_data;
-			size_t			_size;
-			size_t			_writeBytesAvail;
-			int				_readPtr;
-			int				_writePtr;
+			unsigned char*	fData;
+			size_t			fSize;
+			size_t			fWriteBytesAvail;
+			int				fReadPtr;
+			int				fWritePtr;
 
-			uint32			_alignMask;
+			uint32			fAlignMask;
 };