00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023 #include "osfunc.h"
00024
00025 #ifdef WIN32
00026 #include <windows.h>
00027 #else
00028
00029 #ifdef __linux__
00030 #include <sys/sysinfo.h>
00031 #elif defined(__APPLE__) || defined(__FreeBSD__)
00032 #include <sys/types.h>
00033 #include <sys/sysctl.h>
00034 #elif defined(__sun)
00035 #include <unistd.h>
00036 #endif
00037
00038 #endif //WIN32
00039
00040 namespace lux
00041 {
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052 int osHardwareConcurrency() {
00053 #ifdef WIN32
00054 SYSTEM_INFO info={0};
00055 GetSystemInfo(&info);
00056 return info.dwNumberOfProcessors;
00057 #else
00058
00059 #if defined(PTW32_VERSION) || defined(__hpux)
00060 return pthread_num_processors_np();
00061 #elif defined(__linux__)
00062 return get_nprocs();
00063 #elif defined(__APPLE__) || defined(__FreeBSD__)
00064 int count;
00065 size_t size=sizeof(count);
00066 return sysctlbyname("hw.ncpu",&count,&size,NULL,0)?0:count;
00067 #elif defined(__sun)
00068 int const count=sysconf(_SC_NPROCESSORS_ONLN);
00069 return (count>0)?count:0;
00070 #else
00071 return 0;
00072 #endif
00073
00074 #endif // WIN32
00075 }
00076
00077
00078
00079 bool osIsLittleEndian() {
00080 union ShortBytes {
00081 short shortValue;
00082 unsigned char bytes[2];
00083 };
00084
00085 ShortBytes shortTest;
00086 shortTest.shortValue = 1;
00087
00088 return (shortTest.bytes[0] == 1);
00089 }
00090
00091 void osWriteLittleEndianFloat(bool isLittleEndian,
00092 std::basic_ostream<char> &os, float value) {
00093 if(isLittleEndian)
00094 os.write((char *)&value, sizeof(float));
00095 else {
00096 union FloatBytes {
00097 float floatValue;
00098 unsigned char bytes[sizeof(float)];
00099 };
00100
00101 FloatBytes f;
00102 f.floatValue = value;
00103
00104 for(unsigned int i = 0; i < sizeof(float); i++)
00105 os.write((char *)&f.bytes[sizeof(float) - i - 1], 1);
00106 }
00107 }
00108
00109 float osReadLittleEndianFloat(bool isLittleEndian,
00110 std::basic_istream<char> &is) {
00111 if(isLittleEndian) {
00112 float value;
00113 is.read((char *)&value, sizeof(float));
00114 return value;
00115 } else {
00116 union FloatBytes {
00117 float floatValue;
00118 unsigned char bytes[4];
00119 };
00120
00121 FloatBytes f;
00122
00123 for(unsigned int i = 0; i < sizeof(float); i++)
00124 is.read((char *)&f.bytes[sizeof(float) - i - 1], 1);
00125
00126 return f.floatValue;
00127 }
00128 }
00129
00130 void osWriteLittleEndianDouble(bool isLittleEndian,
00131 std::basic_ostream<char> &os, double value)
00132 {
00133 if(isLittleEndian)
00134 os.write((char *)&value, sizeof(double));
00135 else {
00136 union DoubleBytes {
00137 double doubleValue;
00138 unsigned char bytes[sizeof(double)];
00139 } f;
00140
00141 f.doubleValue = value;
00142
00143 for(unsigned int i = 0; i < sizeof(double); ++i)
00144 os.write((char *)&f.bytes[sizeof(double) - i - 1], 1);
00145 }
00146 }
00147
00148 double osReadLittleEndianDouble(bool isLittleEndian,
00149 std::basic_istream<char> &is)
00150 {
00151 if(isLittleEndian) {
00152 double value;
00153 is.read((char *)&value, sizeof(double));
00154 return value;
00155 } else {
00156 union DoubleBytes {
00157 double doubleValue;
00158 unsigned char bytes[sizeof(double)];
00159 } f;
00160
00161 for (unsigned int i = 0; i < sizeof(double); ++i)
00162 is.read((char *)&f.bytes[sizeof(double) - i - 1], 1);
00163
00164 return f.doubleValue;
00165 }
00166 }
00167
00168 void osWriteLittleEndianInt(bool isLittleEndian,
00169 std::basic_ostream<char> &os, int32_t value) {
00170 if(isLittleEndian)
00171 os.write((char *)&value, sizeof(int32_t));
00172 else {
00173 union IntBytes {
00174 int32_t intValue;
00175 unsigned char bytes[sizeof(int32_t)];
00176 };
00177
00178 IntBytes f;
00179 f.intValue = value;
00180
00181 for(unsigned int i = 0; i < sizeof(int32_t); i++)
00182 os.write((char *)&f.bytes[sizeof(int32_t) - i - 1], 1);
00183 }
00184 }
00185
00186 int32_t osReadLittleEndianInt(bool isLittleEndian,
00187 std::basic_istream<char> &is) {
00188 if(isLittleEndian) {
00189 int32_t value;
00190 is.read((char *)&value, sizeof(int32_t));
00191 return value;
00192 } else {
00193 union IntBytes {
00194 int32_t intValue;
00195 unsigned char bytes[sizeof(int32_t)];
00196 };
00197
00198 IntBytes f;
00199
00200 for(unsigned int i = 0; i < sizeof(int32_t); i++)
00201 is.read((char *)&f.bytes[sizeof(int32_t) - i - 1], 1);
00202
00203 return f.intValue;
00204 }
00205 }
00206
00207 void osWriteLittleEndianUInt(bool isLittleEndian,
00208 std::basic_ostream<char> &os, uint32_t value) {
00209 if(isLittleEndian)
00210 os.write((char *)&value, sizeof(uint32_t));
00211 else {
00212 union IntBytes {
00213 uint32_t intValue;
00214 unsigned char bytes[sizeof(uint32_t)];
00215 };
00216
00217 IntBytes f;
00218 f.intValue = value;
00219
00220 for (unsigned int i = 0; i < sizeof(uint32_t); ++i)
00221 os.write((char *)&f.bytes[sizeof(uint32_t) - i - 1], 1);
00222 }
00223 }
00224
00225 uint32_t osReadLittleEndianUInt(bool isLittleEndian,
00226 std::basic_istream<char> &is) {
00227 if(isLittleEndian) {
00228 uint32_t value;
00229 is.read((char *)&value, sizeof(uint32_t));
00230 return value;
00231 } else {
00232 union IntBytes {
00233 uint32_t intValue;
00234 unsigned char bytes[sizeof(uint32_t)];
00235 };
00236
00237 IntBytes f;
00238 for(unsigned int i = 0; i < sizeof(uint32_t); ++i)
00239 is.read((char *)&f.bytes[sizeof(uint32_t) - i - 1], 1);
00240
00241 return f.intValue;
00242 }
00243 }
00244
00245 }