Go to the documentation of this file.00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027 #include <ctype.h>
00028
00029 #if (defined(__GNUC__) && __GNUC__ == 2)
00030 #define NOCREATE ios::nocreate
00031 #else
00032 #if defined(macintosh) //not sure if this is still needed
00033 #define toascii(X) (X) //not sure if this is still needed
00034 #endif //not sure if this is still needed
00035 #define NOCREATE ((std::ios_base::openmode)0)
00036 #endif
00037
00038 #include "id3/utils.h"
00039
00040 #if defined HAVE_ICONV_H
00041
00042 #if (defined(ID3_ICONV_FORMAT_UTF16BE) && defined(ID3_ICONV_FORMAT_UTF16) && defined(ID3_ICONV_FORMAT_UTF8) && defined(ID3_ICONV_FORMAT_ASCII))
00043 # include <iconv.h>
00044 # include <errno.h>
00045 #else
00046 # undef HAVE_ICONV_H
00047 #endif
00048 #endif
00049
00050
00051 dami::String mbstoucs(dami::String data)
00052 {
00053 size_t size = data.size();
00054 dami::String unicode(size * 2, '\0');
00055 for (size_t i = 0; i < size; ++i)
00056 {
00057 unicode[i*2+1] = toascii(data[i]);
00058 }
00059 return unicode;
00060 }
00061
00062
00063 dami::String ucstombs(dami::String data)
00064 {
00065 size_t size = data.size() / 2;
00066 dami::String ascii(size, '\0');
00067 for (size_t i = 0; i < size; ++i)
00068 {
00069 ascii[i] = toascii(data[i*2+1]);
00070 }
00071 return ascii;
00072 }
00073
00074 dami::String oldconvert(dami::String data, ID3_TextEnc sourceEnc, ID3_TextEnc targetEnc)
00075 {
00076 dami::String target;
00077 #define ID3_IS_ASCII(enc) ((enc) == ID3TE_ASCII || (enc) == ID3TE_ISO8859_1 || (enc) == ID3TE_UTF8)
00078 #define ID3_IS_UNICODE(enc) ((enc) == ID3TE_UNICODE || (enc) == ID3TE_UTF16 || (enc) == ID3TE_UTF16BE)
00079 if (ID3_IS_ASCII(sourceEnc) && ID3_IS_UNICODE(targetEnc))
00080 {
00081 target = mbstoucs(data);
00082 }
00083 else if (ID3_IS_UNICODE(sourceEnc) && ID3_IS_ASCII(targetEnc))
00084 {
00085 target = ucstombs(data);
00086 }
00087 return target;
00088 }
00089
00090 using namespace dami;
00091
00092 size_t dami::renderNumber(uchar *buffer, uint32 val, size_t size)
00093 {
00094 uint32 num = val;
00095 for (size_t i = 0; i < size; i++)
00096 {
00097 buffer[size - i - 1] = (uchar)(num & MASK8);
00098 num >>= 8;
00099 }
00100 return size;
00101 }
00102
00103 String dami::renderNumber(uint32 val, size_t size)
00104 {
00105 String str(size, '\0');
00106 uint32 num = val;
00107 for (size_t i = 0; i < size; i++)
00108 {
00109 str[size - i - 1] = (uchar)(num & MASK8);
00110 num >>= 8;
00111 }
00112 return str;
00113 }
00114
00115
00116 #if defined(HAVE_ICONV_H)
00117
00118 namespace
00119 {
00120 String convert_i(iconv_t cd, String source)
00121 {
00122 String target;
00123 size_t source_size = source.size();
00124 #if defined(ID3LIB_ICONV_OLDSTYLE)
00125 const char* source_str = source.data();
00126 #else
00127 char *source_str = new char[source.size()+1];
00128 source.copy(source_str, String::npos);
00129 source_str[source.length()] = 0;
00130 #endif
00131
00132 #define ID3LIB_BUFSIZ 1024
00133 char buf[ID3LIB_BUFSIZ];
00134 char* target_str = buf;
00135 size_t target_size = ID3LIB_BUFSIZ;
00136
00137 do
00138 {
00139 errno = 0;
00140 size_t nconv = iconv(cd,
00141 &source_str, &source_size,
00142 &target_str, &target_size);
00143 if (nconv == (size_t) -1 && errno != EINVAL && errno != E2BIG)
00144 {
00145
00146 return target;
00147 }
00148 target.append(buf, ID3LIB_BUFSIZ - target_size);
00149 target_str = buf;
00150 target_size = ID3LIB_BUFSIZ;
00151 }
00152 while (source_size > 0);
00153 return target;
00154 }
00155
00156 const char* getFormat(ID3_TextEnc enc)
00157 {
00158 const char* format = NULL;
00159 switch (enc)
00160 {
00161 case ID3TE_ASCII:
00162 format = ID3_ICONV_FORMAT_ASCII;
00163 break;
00164
00165 case ID3TE_UTF16:
00166 format = ID3_ICONV_FORMAT_UTF16;
00167 break;
00168
00169 case ID3TE_UTF16BE:
00170 format = ID3_ICONV_FORMAT_UTF16BE;
00171 break;
00172
00173 case ID3TE_UTF8:
00174 format = ID3_ICONV_FORMAT_UTF8;
00175 break;
00176
00177 default:
00178 break;
00179 }
00180 return format;
00181 }
00182 }
00183 #endif
00184
00185 String dami::convert(String data, ID3_TextEnc sourceEnc, ID3_TextEnc targetEnc)
00186 {
00187 String target;
00188 if ((sourceEnc != targetEnc) && (data.size() > 0 ))
00189 {
00190 #if !defined HAVE_ICONV_H
00191 target = oldconvert(data, sourceEnc, targetEnc);
00192 #else
00193 const char* targetFormat = getFormat(targetEnc);
00194 const char* sourceFormat = getFormat(sourceEnc);
00195
00196 iconv_t cd = iconv_open (targetFormat, sourceFormat);
00197 if (cd != (iconv_t) -1)
00198 {
00199 target = convert_i(cd, data);
00200 if (target.size() == 0)
00201 {
00202
00203 target = oldconvert(data, sourceEnc, targetEnc);
00204 }
00205 }
00206 else
00207 {
00208 target = oldconvert(data, sourceEnc, targetEnc);
00209 }
00210 iconv_close (cd);
00211 #endif
00212 }
00213 return target;
00214 }
00215
00216 size_t dami::ucslen(const unicode_t *unicode)
00217 {
00218 if (NULL != unicode)
00219 {
00220 for (size_t size = 0; true; size++)
00221 {
00222 if (NULL_UNICODE == unicode[size])
00223 {
00224 return size;
00225 }
00226 }
00227 }
00228 return 0;
00229 }
00230
00231 namespace
00232 {
00233 bool exists(String name)
00234 {
00235 ifstream file(name.c_str(), NOCREATE);
00236 return file.is_open() != 0;
00237 }
00238 };
00239
00240 ID3_Err dami::createFile(String name, fstream& file)
00241 {
00242 if (file.is_open())
00243 {
00244 file.close();
00245 }
00246
00247 file.open(name.c_str(), ios::in | ios::out | ios::binary | ios::trunc);
00248 if (!file)
00249 {
00250 return ID3E_ReadOnly;
00251 }
00252
00253 return ID3E_NoError;
00254 }
00255
00256 size_t dami::getFileSize(fstream& file)
00257 {
00258 size_t size = 0;
00259 if (file.is_open())
00260 {
00261 streamoff curpos = file.tellg();
00262 file.seekg(0, ios::end);
00263 size = file.tellg();
00264 file.seekg(curpos);
00265 }
00266 return size;
00267 }
00268
00269 size_t dami::getFileSize(ifstream& file)
00270 {
00271 size_t size = 0;
00272 if (file.is_open())
00273 {
00274 streamoff curpos = file.tellg();
00275 file.seekg(0, ios::end);
00276 size = file.tellg();
00277 file.seekg(curpos);
00278 }
00279 return size;
00280 }
00281
00282 size_t dami::getFileSize(ofstream& file)
00283 {
00284 size_t size = 0;
00285 if (file.is_open())
00286 {
00287 streamoff curpos = file.tellp();
00288 file.seekp(0, ios::end);
00289 size = file.tellp();
00290 file.seekp(curpos);
00291 }
00292 return size;
00293 }
00294
00295 ID3_Err dami::openWritableFile(String name, fstream& file)
00296 {
00297 if (!exists(name))
00298 {
00299 return ID3E_NoFile;
00300 }
00301
00302 if (file.is_open())
00303 {
00304 file.close();
00305 }
00306 file.open(name.c_str(), ios::in | ios::out | ios::binary | NOCREATE);
00307 if (!file)
00308 {
00309 return ID3E_ReadOnly;
00310 }
00311
00312 return ID3E_NoError;
00313 }
00314
00315 ID3_Err dami::openWritableFile(String name, ofstream& file)
00316 {
00317 if (!exists(name))
00318 {
00319 return ID3E_NoFile;
00320 }
00321
00322 if (file.is_open())
00323 {
00324 file.close();
00325 }
00326 file.open(name.c_str(), ios::in | ios::out | ios::binary | NOCREATE);
00327 if (!file)
00328 {
00329 return ID3E_ReadOnly;
00330 }
00331
00332 return ID3E_NoError;
00333 }
00334
00335 ID3_Err dami::openReadableFile(String name, fstream& file)
00336 {
00337 if (file.is_open())
00338 {
00339 file.close();
00340 }
00341 file.open(name.c_str(), ios::in | ios::binary | NOCREATE);
00342 if (!file)
00343 {
00344 return ID3E_NoFile;
00345 }
00346
00347 return ID3E_NoError;
00348 }
00349
00350 ID3_Err dami::openReadableFile(String name, ifstream& file)
00351 {
00352 if (file.is_open())
00353 {
00354 file.close();
00355 }
00356 file.open(name.c_str(), ios::in | ios::binary | NOCREATE);
00357 if (!file)
00358 {
00359 return ID3E_NoFile;
00360 }
00361
00362 return ID3E_NoError;
00363 }
00364
00365 String dami::toString(uint32 val)
00366 {
00367 if (val == 0)
00368 {
00369 return "0";
00370 }
00371 String text;
00372 while (val > 0)
00373 {
00374 String tmp;
00375 char ch = (val % 10) + '0';
00376 tmp += ch;
00377 text = tmp + text;
00378 val /= 10;
00379 }
00380 return text;
00381 }
00382
00383 WString dami::toWString(const unicode_t buf[], size_t len)
00384 {
00385 WString str;
00386 str.reserve(len);
00387
00388 for (size_t i = 0; i < len; ++i)
00389 {
00390 str += static_cast<WString::value_type>(buf[i]);
00391 }
00392 return str;
00393 }
00394