diff --git a/headers/os/translation/BitmapStream.h b/headers/os/translation/BitmapStream.h index 057d5a0f1c..be6223be65 100644 --- a/headers/os/translation/BitmapStream.h +++ b/headers/os/translation/BitmapStream.h @@ -1,113 +1,54 @@ -/*****************************************************************************/ -// File: BitmapStream.h -// Class: BBitmapStream -// Reimplemented by: Travis Smith, Michael Wilber, Translation Kit Team -// Reimplementation: 2002-04 -// -// Description: BPositionIO based object to read/write bitmap format to/from -// a BBitmap object. -// -// The BTranslationUtils class uses this object and makes it -// easy for users to load bitmaps. -// -// Copyright (c) 2002 OpenBeOS Project -// -// Original Version: Copyright 1998, Be Incorporated, All Rights Reserved. -// Copyright 1995-1997, Jon Watte -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. -/*****************************************************************************/ - -#if !defined(_BITMAP_STREAM_H) +/* + * Copyright 2009, Haiku Inc. All Rights Reserved. + * Distributed under the terms of the MIT License. + */ +#ifndef _BITMAP_STREAM_H #define _BITMAP_STREAM_H -#include -#include -#include -#include + #include +#include +#include +#include + class BBitmap; + class BBitmapStream : public BPositionIO { public: - BBitmapStream(BBitmap *bitmap = NULL); - // Initializes the stream to use map as the bitmap for stream - // operations. If map is null, a BBitmap is created when properly - // formatted data is written to the stream. - - ~BBitmapStream(); - // Destroys the BBitmap held by this object if it has not been - // detached and frees fpBigEndianHeader + BBitmapStream(BBitmap* bitmap = NULL); + virtual ~BBitmapStream(); - // Overrides from BPositionIO - ssize_t ReadAt(off_t pos, void *buffer, size_t size); - // reads data from the bitmap into buffer - ssize_t WriteAt(off_t pos, const void *data, size_t size); - // writes the data from data into this bitmap - // (if the data is properly formatted) - off_t Seek(off_t position, uint32 whence); - // sets the stream position member - off_t Position() const; - // returns the current stream position - off_t Size() const; - // returns the size of the data - status_t SetSize(off_t size); - // sets the amount of memory to be used by this object + virtual ssize_t ReadAt(off_t offset, void* buffer, size_t size); + virtual ssize_t WriteAt(off_t offset, const void* buffer, + size_t size); + virtual off_t Seek(off_t position, uint32 seekMode); + virtual off_t Position() const; + virtual off_t Size() const; + virtual status_t SetSize(off_t size); - status_t DetachBitmap(BBitmap **outMap); - // "Detaches" the bitmap used by this stream and returns it - // to the user through outMap. This allows the user to - // use the bitmap even after the BBitmapStream that it - // came from has been deleted. + status_t DetachBitmap(BBitmap** _bitmap); protected: - TranslatorBitmap fHeader; - // stores the bitmap header information in the - // host format, used to determine the format of - // the bitmap data and to see if the data is valid - BBitmap *fBitmap; - // the actual bitmap used by this object - size_t fPosition; - // current data position - size_t fSize; - // size of the data stored - bool fDetached; - // true if the bitmap has been detached, false if not + void SwapHeader(const TranslatorBitmap* source, + TranslatorBitmap* destination); + +protected: + TranslatorBitmap fHeader; + BBitmap* fBitmap; + size_t fPosition; + size_t fSize; + bool fDetached; - void SwapHeader(const TranslatorBitmap *source, - TranslatorBitmap *destination); - // swaps the byte order of source, no matter what the - // byte order of source is, and copies the result to - // destination - private: - TranslatorBitmap *fpBigEndianHeader; - // same data as in fHeader, but in Big Endian format - // (Intel machines are Little Endian) - - // For maintaining binary compatibility with past and future - // versions of this object - long fUnused[5]; virtual void _ReservedBitmapStream1(); virtual void _ReservedBitmapStream2(); + +private: + TranslatorBitmap* fBigEndianHeader; + long _reserved[5]; }; -#endif /* _BITMAP_STREAM_H */ +#endif // _BITMAP_STREAM_H diff --git a/src/kits/translation/BitmapStream.cpp b/src/kits/translation/BitmapStream.cpp index c6139f14cb..f2af83d77c 100644 --- a/src/kits/translation/BitmapStream.cpp +++ b/src/kits/translation/BitmapStream.cpp @@ -1,69 +1,38 @@ -/*****************************************************************************/ -// Copyright (c) 2002-2005 Haiku Project -// -// Reimplemented by: Travis Smith, Michael Wilber, Translation Kit Team -// -// Description: BPositionIO based object to read/write bitmap format to/from -// a BBitmap object. -// -// The BTranslationUtils class uses this object and makes it -// easy for users to load bitmaps. -// -// Original Version: Copyright 1998, Be Incorporated, All Rights Reserved. -// Copyright 1995-1997, Jon Watte -// -// Permission is hereby granted, free of charge, to any person obtaining a -// copy of this software and associated documentation files (the "Software"), -// to deal in the Software without restriction, including without limitation -// the rights to use, copy, modify, merge, publish, distribute, sublicense, -// and/or sell copies of the Software, and to permit persons to whom the -// Software is furnished to do so, subject to the following conditions: -// -// The above copyright notice and this permission notice shall be included -// in all copies or substantial portions of the Software. -// -// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS -// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL -// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING -// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER -// DEALINGS IN THE SOFTWARE. -/*****************************************************************************/ +/* + * Copyright 2002-2009, Haiku, Inc. + * Distributed under the terms of the MIT License. + * + * Authors: + * Travis Smith + * Michael Wilber + */ + #include -#include -#include + #include +#include +#include -// --------------------------------------------------------------- -// Constructor -// -// Initializes this object to either use the BBitmap passed to -// it as the object to read/write to or to create a BBitmap -// when data is written to this object. -// -// Preconditions: -// -// Parameters: bitmap, the bitmap used to read from/write to, -// if it is NULL, a bitmap is created when -// this object is written to -// -// Postconditions: -// -// Returns: -// --------------------------------------------------------------- -BBitmapStream::BBitmapStream(BBitmap *bitmap) + +/*! Initializes this object to either use the BBitmap passed to + it as the object to read/write to or to create a BBitmap + when data is written to this object. + + \param bitmap the bitmap used to read from/write to, if it is NULL, a + bitmap is created when this object is written to. +*/ +BBitmapStream::BBitmapStream(BBitmap* bitmap) { fBitmap = bitmap; fDetached = false; fPosition = 0; fSize = 0; - fpBigEndianHeader = new TranslatorBitmap; - + fBigEndianHeader = new TranslatorBitmap; + // Extract header information if bitmap is available - if (fBitmap) { + if (fBitmap != NULL) { fHeader.magic = B_TRANSLATOR_BITMAP; fHeader.bounds = fBitmap->Bounds(); fHeader.rowBytes = fBitmap->BytesPerRow(); @@ -71,70 +40,42 @@ BBitmapStream::BBitmapStream(BBitmap *bitmap) fHeader.dataSize = static_cast ((fHeader.bounds.Height() + 1) * fHeader.rowBytes); fSize = sizeof(TranslatorBitmap) + fHeader.dataSize; - + if (B_HOST_IS_BENDIAN) - memcpy(fpBigEndianHeader, &fHeader, sizeof(TranslatorBitmap)); + memcpy(fBigEndianHeader, &fHeader, sizeof(TranslatorBitmap)); else - SwapHeader(&fHeader, fpBigEndianHeader); + SwapHeader(&fHeader, fBigEndianHeader); } } -// --------------------------------------------------------------- -// Destructor -// -// Destroys memory used by this object, but does not destroy the -// bitmap used by this object if it has been detached. This is so -// the user can use that bitmap after this object is destroyed. -// -// Preconditions: -// -// Parameters: -// -// Postconditions: -// -// Returns: -// --------------------------------------------------------------- + BBitmapStream::~BBitmapStream() { if (!fDetached) delete fBitmap; - fBitmap = NULL; - - delete fpBigEndianHeader; - fpBigEndianHeader = NULL; + + delete fBigEndianHeader; } -// --------------------------------------------------------------- -// ReadAt -// -// Reads data from the stream at a specific position and for a -// specific amount. The first sizeof(TranslatorBitmap) bytes -// are the bitmap header. The header is always written out -// and read in as Big Endian byte order. -// -// Preconditions: -// -// Parameters: pos, the position in the stream to read from -// buffer, where the data will be read into -// size, the amount of data to read -// -// Postconditions: -// -// Returns: B_ERROR if there is no bitmap stored by the stream -// or if pos is a bad value, -// B_BAD_VALUE if buffer is NULL or pos is invalid -// or the amount read if the result >= 0 -// --------------------------------------------------------------- + +/*! Reads data from the stream at a specific position and for a + specific amount. The first sizeof(TranslatorBitmap) bytes + are the bitmap header. The header is always written out + and read in as Big Endian byte order. + + \param pos, the position in the stream to read from buffer, where the data + will be read into size, the amount of data to read + \return B_ERROR if there is no bitmap stored by the stream, B_BAD_VALUE if + buffer is NULL or pos is invalid or the amount read if the result >= 0 +*/ ssize_t -BBitmapStream::ReadAt(off_t pos, void *buffer, size_t size) +BBitmapStream::ReadAt(off_t pos, void* buffer, size_t size) { if (!fBitmap) return B_ERROR; - if (!size) - return B_NO_ERROR; - if (pos >= fSize) - return B_ERROR; - if (!buffer || pos < 0) + if (size == 0) + return B_OK; + if (pos >= fSize || pos < 0 || buffer == NULL) return B_BAD_VALUE; ssize_t toRead; @@ -142,7 +83,7 @@ BBitmapStream::ReadAt(off_t pos, void *buffer, size_t size) if (pos < sizeof(TranslatorBitmap)) { toRead = sizeof(TranslatorBitmap) - pos; - source = (reinterpret_cast(fpBigEndianHeader)) + pos; + source = (reinterpret_cast(fBigEndianHeader)) + pos; } else { toRead = fSize - pos; source = (reinterpret_cast(fBitmap->Bits())) + pos - @@ -155,31 +96,22 @@ BBitmapStream::ReadAt(off_t pos, void *buffer, size_t size) return toRead; } -// --------------------------------------------------------------- -// WriteAt -// -// Writes data to the bitmap from data, starting at position pos -// of size, size. The first sizeof(TranslatorBitmap) bytes -// of data must be the TranslatorBitmap header in the Big -// Endian byte order, otherwise, the data will fail to be -// successfully written. -// -// Preconditions: -// -// Parameters: pos, the position in the stream to write to -// data, the data to write to the stream -// size, the size of the data to write to the stream -// -// Postconditions: -// -// Returns: B_BAD_VALUE if size is bad or data is NULL or pos is invalid, -// B_MISMATCHED_VALUES if the bitmap header is bad, -// B_ERROR if error allocating memory or setting up -// big endian header, -// or the amount written if the result is >= 0 -// --------------------------------------------------------------- + +/*! Writes data to the bitmap from data, starting at position pos + of size, size. The first sizeof(TranslatorBitmap) bytes + of data must be the TranslatorBitmap header in the Big + Endian byte order, otherwise, the data will fail to be + successfully written. + + \param pos, the position in the stream to write to data, the data to write + to the stream size, the size of the data to write to the stream + \return B_BAD_VALUE if size is bad or data is NULL or pos is invalid, + B_MISMATCHED_VALUES if the bitmap header is bad, + B_ERROR if error allocating memory or setting up big endian header, + or the amount written if the result is >= 0 +*/ ssize_t -BBitmapStream::WriteAt(off_t pos, const void *data, size_t size) +BBitmapStream::WriteAt(off_t pos, const void* data, size_t size) { if (!size) return B_NO_ERROR; @@ -216,10 +148,10 @@ BBitmapStream::WriteAt(off_t pos, const void *data, size_t size) // If we change the header, the rest needs to be reset if (pos == sizeof(TranslatorBitmap)) { // Setup both host and Big Endian byte order bitmap headers - memcpy(fpBigEndianHeader, &fHeader, sizeof(TranslatorBitmap)); + memcpy(fBigEndianHeader, &fHeader, sizeof(TranslatorBitmap)); if (B_HOST_IS_LENDIAN) - SwapHeader(fpBigEndianHeader, &fHeader); - + SwapHeader(fBigEndianHeader, &fHeader); + if (fBitmap && (fBitmap->Bounds() != fHeader.bounds || fBitmap->ColorSpace() != fHeader.colors @@ -236,7 +168,8 @@ BBitmapStream::WriteAt(off_t pos, const void *data, size_t size) if (!fBitmap) return B_ERROR; if ((uint32)fBitmap->BytesPerRow() != fHeader.rowBytes) { - fprintf(stderr, "BitmapStream %ld %ld\n", fBitmap->BytesPerRow(), fHeader.rowBytes); + fprintf(stderr, "BitmapStream %ld %ld\n", + fBitmap->BytesPerRow(), fHeader.rowBytes); return B_MISMATCHED_VALUES; } } @@ -247,59 +180,37 @@ BBitmapStream::WriteAt(off_t pos, const void *data, size_t size) return written; } -// --------------------------------------------------------------- -// Seek -// -// Changes the current stream position. -// -// Preconditions: -// -// Parameters: position, the position offset -// whence, decides how the position offset is used -// SEEK_CUR, position is added to current -// stream position -// SEEK_END, position is added to the end -// stream position -// SEEK_SET, the stream position is set to -// position -// -// Postconditions: -// -// Returns: B_BAD_VALUE if the position is bad -// or the new position value if the result >= 0 -// --------------------------------------------------------------- + +/*! Changes the current stream position. + + \param position the position offset + \param seekMode decides how the position offset is used: + SEEK_CUR, position is added to current stream position + SEEK_END, position is added to the end stream position + SEEK_SET, the stream position is set to position + \return B_BAD_VALUE if the position is bad or the new position value if the + result >= 0 +*/ off_t -BBitmapStream::Seek(off_t position, uint32 whence) +BBitmapStream::Seek(off_t position, uint32 seekMode) { // When whence == SEEK_SET, it just falls through to // fPosition = position - if (whence == SEEK_CUR) + if (seekMode == SEEK_CUR) position += fPosition; - if (whence == SEEK_END) + else if (seekMode == SEEK_END) position += fSize; - if (position < 0) + if (position < 0 || position > fSize) return B_BAD_VALUE; - if (position > fSize) - return B_BAD_VALUE; - + fPosition = position; return fPosition; } -// --------------------------------------------------------------- -// Position -// -// Returns the current stream position -// -// Preconditions: -// -// Parameters: -// -// Postconditions: -// -// Returns: returns the curren stream position -// --------------------------------------------------------------- + +/*! Returns the current stream position +*/ off_t BBitmapStream::Position() const { @@ -307,40 +218,23 @@ BBitmapStream::Position() const } -// --------------------------------------------------------------- -// Size -// -// Returns the curren stream size -// -// Preconditions: -// -// Parameters: -// -// Postconditions: -// -// Returns: returns the current stream size -// --------------------------------------------------------------- + +/*! Returns the curren stream size +*/ off_t BBitmapStream::Size() const { return fSize; } -// --------------------------------------------------------------- -// SetSize -// -// Sets the size of the data, but I'm not sure if this function -// has any real purpose. -// -// Preconditions: -// -// Parameters: size, the size to set the stream size to. -// -// Postconditions: -// -// Returns: B_BAD_VALUE, if size is a bad value -// B_NO_ERROR, if size is a valid value -// --------------------------------------------------------------- + +/*! Sets the size of the data, but I'm not sure if this function has any real + purpose. + + \param size the size to set the stream size to. + \return B_BAD_VALUE, if size is a bad value, B_NO_ERROR, if size is a + valid value +*/ status_t BBitmapStream::SetSize(off_t size) { @@ -348,117 +242,62 @@ BBitmapStream::SetSize(off_t size) return B_BAD_VALUE; if (fBitmap && (size > fHeader.dataSize + sizeof(TranslatorBitmap))) return B_BAD_VALUE; - // Problem: - // What if someone calls SetSize() before writing the header, - // so we don't know what bitmap to create? - // Solution: - // We assume people will write the header before any data, - // so SetSize() is really not going to do anything. - if (fBitmap) - // if we checked that the size was OK + // Problem: + // What if someone calls SetSize() before writing the header, + // so we don't know what bitmap to create? + // Solution: + // We assume people will write the header before any data, + // so SetSize() is really not going to do anything. + if (fBitmap != NULL) fSize = size; return B_NO_ERROR; } -// --------------------------------------------------------------- -// DetachBitmap -// -// Returns the internal bitmap through outBitmap so the user -// can do whatever they want to it. It means that when the -// BBitmapStream is deleted, the bitmap is not deleted. After -// the bitmap has been detached, it is still used by the stream, -// but it is never deleted by the stream. -// -// Preconditions: -// -// Parameters: outBitmap, where the bitmap is detached to -// -// Postconditions: -// -// Returns: B_BAD_VALUE, if outBitmap is NULL -// B_ERROR, if the bitmap is NULL or -// has already been detached -// B_NO_ERROR, if the bitmap was successfully detached -// --------------------------------------------------------------- + +/*! Returns the internal bitmap through outBitmap so the user + can do whatever they want to it. It means that when the + BBitmapStream is deleted, the bitmap is not deleted. After + the bitmap has been detached, it is still used by the stream, + but it is never deleted by the stream. + + \param _bitmap where the bitmap is detached to + \return B_BAD_VALUE, if outBitmap is NULL, B_ERROR, if the bitmap is NULL or + has already been detached, B_OK, if the bitmap was successfully detached +*/ status_t -BBitmapStream::DetachBitmap(BBitmap **outBitmap) +BBitmapStream::DetachBitmap(BBitmap** _bitmap) { - if (!outBitmap) + if (_bitmap == NULL) return B_BAD_VALUE; - if (!fBitmap || fDetached) { - *outBitmap = NULL; + if (!fBitmap || fDetached) return B_ERROR; - } - + fDetached = true; - *outBitmap = fBitmap; - - return B_NO_ERROR; + *_bitmap = fBitmap; + + return B_OK; } -// --------------------------------------------------------------- -// SwapHeader -// -// Swaps the byte order of source, no matter what the -// byte order, and copies the result to destination -// -// Preconditions: both parameters must not be null -// -// Parameters: source, data to be swapped -// -// destination, where the swapped data will -// be copied to -// -// Postconditions: -// -// Returns: -// -// --------------------------------------------------------------- + +/*! Swaps the byte order of source, no matter what the + byte order, and copies the result to destination + + \param source data to be swapped + \param destination where the swapped data will be copied to +*/ void -BBitmapStream::SwapHeader(const TranslatorBitmap *source, - TranslatorBitmap *destination) +BBitmapStream::SwapHeader(const TranslatorBitmap* source, + TranslatorBitmap* destination) { + if (source == NULL || destination == NULL) + return; + memcpy(destination, source, sizeof(TranslatorBitmap)); swap_data(B_UINT32_TYPE, destination, sizeof(TranslatorBitmap), B_SWAP_ALWAYS); } -// --------------------------------------------------------------- -// _ReservedBitmapStream1() -// -// It doesn't do anything :). Its here only for past/future -// binary compatibility. -// -// Preconditions: -// -// Parameters: -// -// Postconditions: -// -// Returns: -// --------------------------------------------------------------- -void -BBitmapStream::_ReservedBitmapStream1() -{ -} - -// --------------------------------------------------------------- -// _ReservedBitmapStream2() -// -// It doesn't do anything :). Its only here for past/future -// binary compatibility. -// -// Preconditions: -// -// Parameters: -// -// Postconditions: -// -// Returns: -// --------------------------------------------------------------- -void -BBitmapStream::_ReservedBitmapStream2() -{ -} +void BBitmapStream::_ReservedBitmapStream1() {} +void BBitmapStream::_ReservedBitmapStream2() {}