Aren/haiku
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

* Rewrote header.

Browse Source 
* Cleaned up sources.


git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@32752 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Axel Dörfler 2009-08-27 13:40:07 +00:00
parent 2089178aac
commit 8780d2073d
2 changed files with 170 additions and 390 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

129
headers/os/translation/BitmapStream.h
View File

@ -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 <BeBuild.h>
#include <TranslationDefs.h>
#include <DataIO.h>
#include <TranslatorFormats.h>
#include <ByteOrder.h>
#include <DataIO.h>
#include <TranslationDefs.h>
#include <TranslatorFormats.h>
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

431
src/kits/translation/BitmapStream.cpp
View File

@ -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 <BitmapStream.h>
#include <Bitmap.h>
#include <Debug.h>
#include <string.h>
#include <Bitmap.h>
#include <Debug.h>
// ---------------------------------------------------------------
// 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<uint32>
((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<uint8 *>(fpBigEndianHeader)) + pos;
source = (reinterpret_cast<uint8 *>(fBigEndianHeader)) + pos;
} else {
toRead = fSize - pos;
source = (reinterpret_cast<uint8 *>(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() {}