i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Style fixes

Browse Source
This commit is contained in:
Dario Casalinuovo
2016-06-23 00:38:33 +02:00
parent e1c98ceaf7
commit 59ff587d70
2 changed files with 129 additions and 129 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/kits/media/AdapterIO.cpp
+105 -105
View File
@@ -14,140 +14,140 @@
class RelativePositionIO : public BPositionIO class RelativePositionIO : public BPositionIO
{ {
public: public:
RelativePositionIO(BPositionIO* buffer) RelativePositionIO(BPositionIO* buffer)
: :
BPositionIO(), BPositionIO(),
fStartOffset(0), fStartOffset(0),
fTotalSize(0), fTotalSize(0),
fBuffer(buffer) fBuffer(buffer)
{} {}
virtual ~RelativePositionIO() virtual ~RelativePositionIO()
{ {
delete fBuffer; delete fBuffer;
} }
void SetTotalSize(size_t size) void SetTotalSize(size_t size)
{ {
fTotalSize = size; fTotalSize = size;
} }
size_t TotalSize() const size_t TotalSize() const
{ {
return fTotalSize; return fTotalSize;
} }
status_t ResetStartOffset(off_t offset) status_t ResetStartOffset(off_t offset)
{ {
status_t ret = fBuffer->SetSize(0); status_t ret = fBuffer->SetSize(0);
if (ret == B_OK) if (ret == B_OK)
fStartOffset = offset; fStartOffset = offset;
return ret; return ret;
} }
status_t EvaluatePosition(off_t position) status_t EvaluatePosition(off_t position)
{ {
if (position < 0) if (position < 0)
return B_ERROR; return B_ERROR;
if (position < fStartOffset) if (position < fStartOffset)
return B_RESOURCE_UNAVAILABLE; return B_RESOURCE_UNAVAILABLE;
// This is an endless stream, we don't know // This is an endless stream, we don't know
// how much data will come and when, we could // how much data will come and when, we could
// block on that. // block on that.
if (fTotalSize == 0) if (fTotalSize == 0)
return B_WOULD_BLOCK; return B_WOULD_BLOCK;
if (position >= fTotalSize) if (position >= fTotalSize)
return B_ERROR; return B_ERROR;
off_t size = 0; off_t size = 0;
fBuffer->GetSize(&size); fBuffer->GetSize(&size);
if (position >= size) if (position >= size)
return B_RESOURCE_UNAVAILABLE; return B_RESOURCE_UNAVAILABLE;
return B_OK; return B_OK;
} }
status_t WaitForData(off_t position) status_t WaitForData(off_t position)
{ {
off_t bufferSize = 0; off_t bufferSize = 0;
position = _PositionToRelative(position); position = _PositionToRelative(position);
status_t ret = fBuffer->GetSize(&bufferSize); status_t ret = fBuffer->GetSize(&bufferSize);
if (ret != B_OK) if (ret != B_OK)
return B_ERROR; return B_ERROR;
while(bufferSize < position) { while(bufferSize < position) {
snooze(100000); snooze(100000);
fBuffer->GetSize(&bufferSize); fBuffer->GetSize(&bufferSize);
} }
return B_OK; return B_OK;
} }
virtual ssize_t ReadAt(off_t position, void* buffer, virtual ssize_t ReadAt(off_t position, void* buffer,
size_t size) size_t size)
{ {
return fBuffer->ReadAt( return fBuffer->ReadAt(
_PositionToRelative(position), buffer, size); _PositionToRelative(position), buffer, size);
} }
virtual ssize_t WriteAt(off_t position, virtual ssize_t WriteAt(off_t position,
const void* buffer, size_t size) const void* buffer, size_t size)
{ {
return fBuffer->WriteAt( return fBuffer->WriteAt(
_PositionToRelative(position), buffer, size); _PositionToRelative(position), buffer, size);
} }
virtual off_t Seek(off_t position, uint32 seekMode) virtual off_t Seek(off_t position, uint32 seekMode)
{ {
return fBuffer->Seek(_PositionToRelative(position), seekMode); return fBuffer->Seek(_PositionToRelative(position), seekMode);
} }
virtual off_t Position() const virtual off_t Position() const
{ {
return _RelativeToPosition(fBuffer->Position()); return _RelativeToPosition(fBuffer->Position());
} }
virtual status_t SetSize(off_t size) virtual status_t SetSize(off_t size)
{ {
return fBuffer->SetSize(_PositionToRelative(size)); return fBuffer->SetSize(_PositionToRelative(size));
} }
virtual status_t GetSize(off_t* size) const virtual status_t GetSize(off_t* size) const
{ {
if (fTotalSize > 0) { if (fTotalSize > 0) {
*size = fTotalSize; *size = fTotalSize;
return B_OK; return B_OK;
} }
off_t bufferSize; off_t bufferSize;
status_t ret = fBuffer->GetSize(&bufferSize); status_t ret = fBuffer->GetSize(&bufferSize);
if (ret == B_OK) if (ret == B_OK)
*size = _RelativeToPosition(bufferSize); *size = _RelativeToPosition(bufferSize);
return ret; return ret;
} }
private: private:
off_t _PositionToRelative(off_t position) const off_t _PositionToRelative(off_t position) const
{ {
return position - fStartOffset; return position - fStartOffset;
} }
off_t _RelativeToPosition(off_t position) const off_t _RelativeToPosition(off_t position) const
{ {
return position + fStartOffset; return position + fStartOffset;
} }
off_t fStartOffset; off_t fStartOffset;
off_t fTotalSize; off_t fTotalSize;
BPositionIO* fBuffer; BPositionIO* fBuffer;
}; };
src/kits/media/PluginManager.cpp
+24 -24
View File
@@ -28,11 +28,11 @@ PluginManager gPluginManager;
class DataIOAdapter : public BAdapterIO class DataIOAdapter : public BAdapterIO
{ {
public: public:
DataIOAdapter(BDataIO* dataIO) DataIOAdapter(BDataIO* dataIO)
: :
BAdapterIO(B_MEDIA_SEEK_BACKWARD | B_MEDIA_MUTABLE_SIZE, BAdapterIO(B_MEDIA_SEEK_BACKWARD | B_MEDIA_MUTABLE_SIZE,
B_INFINITE_TIMEOUT), B_INFINITE_TIMEOUT),
fDataIO(dataIO) fDataIO(dataIO)
{ {
fDataInputAdapter = BuildInputAdapter(); fDataInputAdapter = BuildInputAdapter();
} }
@@ -138,30 +138,30 @@ public:
// BMediaIO interface // BMediaIO interface
virtual void GetFlags(int32* flags) const virtual void GetFlags(int32* flags) const
{ {
*flags = fFlags; *flags = fFlags;
} }
// BPositionIO interface // BPositionIO interface
virtual ssize_t ReadAt(off_t position, void* buffer, virtual ssize_t ReadAt(off_t position, void* buffer,
size_t size) size_t size)
{ {
CALLED(); CALLED();
return fPosition->ReadAt(position, buffer, size); return fPosition->ReadAt(position, buffer, size);
} }
virtual ssize_t WriteAt(off_t position, const void* buffer, virtual ssize_t WriteAt(off_t position, const void* buffer,
size_t size) size_t size)
{ {
CALLED(); CALLED();
return fPosition->WriteAt(position, buffer, size); return fPosition->WriteAt(position, buffer, size);
} }
virtual off_t Seek(off_t position, uint32 seekMode) virtual off_t Seek(off_t position, uint32 seekMode)
{ {
CALLED(); CALLED();
@@ -169,21 +169,21 @@ public:
} }
virtual off_t Position() const virtual off_t Position() const
{ {
CALLED(); CALLED();
return fPosition->Position(); return fPosition->Position();
} }
virtual status_t SetSize(off_t size) virtual status_t SetSize(off_t size)
{ {
CALLED(); CALLED();
return fPosition->SetSize(size); return fPosition->SetSize(size);
} }
virtual status_t GetSize(off_t* size) const virtual status_t GetSize(off_t* size) const
{ {
CALLED(); CALLED();
@@ -192,33 +192,33 @@ public:
// Utility methods // Utility methods
status_t InitCheck() const status_t InitCheck() const
{ {
return fErr; return fErr;
} }
protected: protected:
bool IsMedia() const bool IsMedia() const
{ {
return fMedia != NULL; return fMedia != NULL;
} }
bool IsPosition() const bool IsPosition() const
{ {
return fPosition != NULL; return fPosition != NULL;
} }
private: private:
BDataIO* fData; BDataIO* fData;
BPositionIO* fPosition; BPositionIO* fPosition;
BMediaIO* fMedia; BMediaIO* fMedia;
BBufferIO* fBufferIO; BBufferIO* fBufferIO;
DataIOAdapter* fDataIOAdapter; DataIOAdapter* fDataIOAdapter;
int32 fFlags; int32 fFlags;
status_t fErr; status_t fErr;
}; };