1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
|
/*
* This is the Loris C++ Class Library, implementing analysis,
* manipulation, and synthesis of digitized sounds using the Reassigned
* Bandwidth-Enhanced Additive Sound Model.
*
* Loris is Copyright (c) 1999-2010 by Kelly Fitz and Lippold Haken
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY, without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
*
* BigEndian.C
*
* Implementation of wrappers for stream-based binary file i/o.
*
* Kelly Fitz, 23 May 2000
* loris@cerlsoundgroup.org
*
* http://www.cerlsoundgroup.org/Loris/
*
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif
#include "BigEndian.h"
#include "LorisExceptions.h"
#include <vector>
#include <iostream>
// begin namespace
namespace Loris {
// ---------------------------------------------------------------------------
// bigEndianSystem
// ---------------------------------------------------------------------------
// Return true is this is a big-endian system, false otherwise.
//
static bool bigEndianSystem( void )
{
#if defined(WORDS_BIGENDIAN)
return true;
#elif HAVE_CONFIG_H && !defined(WORDS_BIGENDIAN)
return false;
#else
static union {
int s ;
char c[sizeof(int)] ;
} x ;
bool ret = (x.s = 1, x.c[0] != 1) ? true : false;
return ret; // x.c[0] != 1;
#endif
}
// ---------------------------------------------------------------------------
// swapByteOrder
// ---------------------------------------------------------------------------
//
static void swapByteOrder( char * bytes, int n )
{
char * beg = bytes, * end = bytes + n - 1;
while ( beg < end ) {
char tmp = *end;
*end = *beg;
*beg = tmp;
++beg;
--end;
}
}
// ---------------------------------------------------------------------------
// BigEndian read
// ---------------------------------------------------------------------------
//
std::istream &
BigEndian::read( std::istream & s, long howmany, int size, char * putemHere )
{
// read the bytes into data:
s.read( putemHere, howmany*size );
// check stream state:
if ( s )
{
// if the stream is still in a good state, then
// the correct number of bytes must have been read:
Assert( s.gcount() == howmany*size );
// swap byte order if nec.
if ( ! bigEndianSystem() && size > 1 )
{
for ( long i = 0; i < howmany; ++i )
{
swapByteOrder( putemHere + (i*size), size );
}
}
}
return s;
}
// ---------------------------------------------------------------------------
// BigEndian write
// ---------------------------------------------------------------------------
//
std::ostream &
BigEndian::write( std::ostream & s, long howmany, int size, const char * stuff )
{
// swap byte order if nec.
if ( ! bigEndianSystem() && size > 1 )
{
// use a temporary vector to automate storage:
std::vector<char> v( stuff, stuff + (howmany*size) );
for ( long i = 0; i < howmany; ++i )
{
swapByteOrder( & v[i*size], size );
}
s.write( &v[0], howmany*size );
}
else
{
// read the bytes into data:
s.write( stuff, howmany*size );
}
// check stream state:
if ( ! s.good() )
Throw( FileIOException, "File write failed. " );
return s;
}
} // end of namespace Loris
|