← Back to branch summary

~ubuntu-dev/ubuntu/lucid/mpd/lucid-201002101854

« back to all changes in this revision

Viewing changes to src/libid3tag/utf8.c

  • Committer: Bazaar Package Importer
  • Author(s): Charles Majola
  • Date: 2005-02-15 10:43:58 UTC
  • Revision ID: james.westby@ubuntu.com-20050215104358-w8b7yaqqfmsoxj5k
Tags: upstream-0.11.5
Import upstream version 0.11.5

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/libid3tag/utf8.c
 
1
/*
 
2
 * libid3tag - ID3 tag manipulation library
 
3
 * Copyright (C) 2000-2004 Underbit Technologies, Inc.
 
4
 *
 
5
 * This program is free software; you can redistribute it and/or modify
 
6
 * it under the terms of the GNU General Public License as published by
 
7
 * the Free Software Foundation; either version 2 of the License, or
 
8
 * (at your option) any later version.
 
9
 *
 
10
 * This program is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
13
 * GNU General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU General Public License
 
16
 * along with this program; if not, write to the Free Software
 
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
18
 *
 
19
 * $Id: utf8.c,v 1.9 2004/01/23 09:41:32 rob Exp $
 
20
 */
 
21
 
 
22
# ifdef HAVE_CONFIG_H
 
23
#  include "config.h"
 
24
# endif
 
25
 
 
26
# include "global.h"
 
27
 
 
28
# include <stdlib.h>
 
29
 
 
30
# include "id3tag.h"
 
31
# include "utf8.h"
 
32
# include "ucs4.h"
 
33
 
 
34
/*
 
35
 * NAME:        utf8->length()
 
36
 * DESCRIPTION: return the number of ucs4 chars represented by a utf8 string
 
37
 */
 
38
id3_length_t id3_utf8_length(id3_utf8_t const *utf8)
 
39
{
 
40
  id3_length_t length = 0;
 
41
 
 
42
  while (*utf8) {
 
43
    if ((utf8[0] & 0x80) == 0x00)
 
44
      ++length;
 
45
    else if ((utf8[0] & 0xe0) == 0xc0 &&
 
46
             (utf8[1] & 0xc0) == 0x80) {
 
47
      if (((utf8[0] & 0x1fL) << 6) >= 0x00000080L) {
 
48
        ++length;
 
49
        utf8 += 1;
 
50
      }
 
51
    }
 
52
    else if ((utf8[0] & 0xf0) == 0xe0 &&
 
53
             (utf8[1] & 0xc0) == 0x80 &&
 
54
             (utf8[2] & 0xc0) == 0x80) {
 
55
      if ((((utf8[0] & 0x0fL) << 12) |
 
56
           ((utf8[1] & 0x3fL) <<  6)) >= 0x00000800L) {
 
57
        ++length;
 
58
        utf8 += 2;
 
59
      }
 
60
    }
 
61
    else if ((utf8[0] & 0xf8) == 0xf0 &&
 
62
             (utf8[1] & 0xc0) == 0x80 &&
 
63
             (utf8[2] & 0xc0) == 0x80 &&
 
64
             (utf8[3] & 0xc0) == 0x80) {
 
65
      if ((((utf8[0] & 0x07L) << 18) |
 
66
           ((utf8[1] & 0x3fL) << 12)) >= 0x00010000L) {
 
67
        ++length;
 
68
        utf8 += 3;
 
69
      }
 
70
    }
 
71
    else if ((utf8[0] & 0xfc) == 0xf8 &&
 
72
             (utf8[1] & 0xc0) == 0x80 &&
 
73
             (utf8[2] & 0xc0) == 0x80 &&
 
74
             (utf8[3] & 0xc0) == 0x80 &&
 
75
             (utf8[4] & 0xc0) == 0x80) {
 
76
      if ((((utf8[0] & 0x03L) << 24) |
 
77
           ((utf8[0] & 0x3fL) << 18)) >= 0x00200000L) {
 
78
        ++length;
 
79
        utf8 += 4;
 
80
      }
 
81
    }
 
82
    else if ((utf8[0] & 0xfe) == 0xfc &&
 
83
             (utf8[1] & 0xc0) == 0x80 &&
 
84
             (utf8[2] & 0xc0) == 0x80 &&
 
85
             (utf8[3] & 0xc0) == 0x80 &&
 
86
             (utf8[4] & 0xc0) == 0x80 &&
 
87
             (utf8[5] & 0xc0) == 0x80) {
 
88
      if ((((utf8[0] & 0x01L) << 30) |
 
89
           ((utf8[0] & 0x3fL) << 24)) >= 0x04000000L) {
 
90
        ++length;
 
91
        utf8 += 5;
 
92
      }
 
93
    }
 
94
 
 
95
    ++utf8;
 
96
  }
 
97
 
 
98
  return length;
 
99
}
 
100
 
 
101
/*
 
102
 * NAME:        utf8->size()
 
103
 * DESCRIPTION: return the encoding size of a utf8 string
 
104
 */
 
105
id3_length_t id3_utf8_size(id3_utf8_t const *utf8)
 
106
{
 
107
  id3_utf8_t const *ptr = utf8;
 
108
 
 
109
  while (*ptr)
 
110
    ++ptr;
 
111
 
 
112
  return ptr - utf8 + 1;
 
113
}
 
114
 
 
115
/*
 
116
 * NAME:        utf8->ucs4duplicate()
 
117
 * DESCRIPTION: duplicate and decode a utf8 string into ucs4
 
118
 */
 
119
id3_ucs4_t *id3_utf8_ucs4duplicate(id3_utf8_t const *utf8)
 
120
{
 
121
  id3_ucs4_t *ucs4;
 
122
 
 
123
  ucs4 = malloc((id3_utf8_length(utf8) + 1) * sizeof(*ucs4));
 
124
  if (ucs4)
 
125
    id3_utf8_decode(utf8, ucs4);
 
126
 
 
127
  return release(ucs4);
 
128
}
 
129
 
 
130
/*
 
131
 * NAME:        utf8->decodechar()
 
132
 * DESCRIPTION: decode a series of utf8 chars into a single ucs4 char
 
133
 */
 
134
id3_length_t id3_utf8_decodechar(id3_utf8_t const *utf8, id3_ucs4_t *ucs4)
 
135
{
 
136
  id3_utf8_t const *start = utf8;
 
137
 
 
138
  while (1) {
 
139
    if ((utf8[0] & 0x80) == 0x00) {
 
140
      *ucs4 = utf8[0];
 
141
      return utf8 - start + 1;
 
142
    }
 
143
    else if ((utf8[0] & 0xe0) == 0xc0 &&
 
144
             (utf8[1] & 0xc0) == 0x80) {
 
145
      *ucs4 =
 
146
        ((utf8[0] & 0x1fL) << 6) |
 
147
        ((utf8[1] & 0x3fL) << 0);
 
148
      if (*ucs4 >= 0x00000080L)
 
149
        return utf8 - start + 2;
 
150
    }
 
151
    else if ((utf8[0] & 0xf0) == 0xe0 &&
 
152
             (utf8[1] & 0xc0) == 0x80 &&
 
153
             (utf8[2] & 0xc0) == 0x80) {
 
154
      *ucs4 =
 
155
        ((utf8[0] & 0x0fL) << 12) |
 
156
        ((utf8[1] & 0x3fL) <<  6) |
 
157
        ((utf8[2] & 0x3fL) <<  0);
 
158
      if (*ucs4 >= 0x00000800L)
 
159
        return utf8 - start + 3;
 
160
    }
 
161
    else if ((utf8[0] & 0xf8) == 0xf0 &&
 
162
             (utf8[1] & 0xc0) == 0x80 &&
 
163
             (utf8[2] & 0xc0) == 0x80 &&
 
164
             (utf8[3] & 0xc0) == 0x80) {
 
165
      *ucs4 =
 
166
        ((utf8[0] & 0x07L) << 18) |
 
167
        ((utf8[1] & 0x3fL) << 12) |
 
168
        ((utf8[2] & 0x3fL) <<  6) |
 
169
        ((utf8[3] & 0x3fL) <<  0);
 
170
      if (*ucs4 >= 0x00010000L)
 
171
        return utf8 - start + 4;
 
172
    }
 
173
    else if ((utf8[0] & 0xfc) == 0xf8 &&
 
174
             (utf8[1] & 0xc0) == 0x80 &&
 
175
             (utf8[2] & 0xc0) == 0x80 &&
 
176
             (utf8[3] & 0xc0) == 0x80 &&
 
177
             (utf8[4] & 0xc0) == 0x80) {
 
178
      *ucs4 =
 
179
        ((utf8[0] & 0x03L) << 24) |
 
180
        ((utf8[1] & 0x3fL) << 18) |
 
181
        ((utf8[2] & 0x3fL) << 12) |
 
182
        ((utf8[3] & 0x3fL) <<  6) |
 
183
        ((utf8[4] & 0x3fL) <<  0);
 
184
      if (*ucs4 >= 0x00200000L)
 
185
        return utf8 - start + 5;
 
186
    }
 
187
    else if ((utf8[0] & 0xfe) == 0xfc &&
 
188
             (utf8[1] & 0xc0) == 0x80 &&
 
189
             (utf8[2] & 0xc0) == 0x80 &&
 
190
             (utf8[3] & 0xc0) == 0x80 &&
 
191
             (utf8[4] & 0xc0) == 0x80 &&
 
192
             (utf8[5] & 0xc0) == 0x80) {
 
193
      *ucs4 =
 
194
        ((utf8[0] & 0x01L) << 30) |
 
195
        ((utf8[1] & 0x3fL) << 24) |
 
196
        ((utf8[2] & 0x3fL) << 18) |
 
197
        ((utf8[3] & 0x3fL) << 12) |
 
198
        ((utf8[4] & 0x3fL) <<  6) |
 
199
        ((utf8[5] & 0x3fL) <<  0);
 
200
      if (*ucs4 >= 0x04000000L)
 
201
        return utf8 - start + 6;
 
202
    }
 
203
 
 
204
    ++utf8;
 
205
  }
 
206
}
 
207
 
 
208
/*
 
209
 * NAME:        utf8->encodechar()
 
210
 * DESCRIPTION: encode a single ucs4 char into a series of up to 6 utf8 chars
 
211
 */
 
212
id3_length_t id3_utf8_encodechar(id3_utf8_t *utf8, id3_ucs4_t ucs4)
 
213
{
 
214
  if (ucs4 <= 0x0000007fL) {
 
215
    utf8[0] = ucs4;
 
216
 
 
217
    return 1;
 
218
  }
 
219
  else if (ucs4 <= 0x000007ffL) {
 
220
    utf8[0] = 0xc0 | ((ucs4 >>  6) & 0x1f);
 
221
    utf8[1] = 0x80 | ((ucs4 >>  0) & 0x3f);
 
222
 
 
223
    return 2;
 
224
  }
 
225
  else if (ucs4 <= 0x0000ffffL) {
 
226
    utf8[0] = 0xe0 | ((ucs4 >> 12) & 0x0f);
 
227
    utf8[1] = 0x80 | ((ucs4 >>  6) & 0x3f);
 
228
    utf8[2] = 0x80 | ((ucs4 >>  0) & 0x3f);
 
229
 
 
230
    return 3;
 
231
  }
 
232
  else if (ucs4 <= 0x001fffffL) {
 
233
    utf8[0] = 0xf0 | ((ucs4 >> 18) & 0x07);
 
234
    utf8[1] = 0x80 | ((ucs4 >> 12) & 0x3f);
 
235
    utf8[2] = 0x80 | ((ucs4 >>  6) & 0x3f);
 
236
    utf8[3] = 0x80 | ((ucs4 >>  0) & 0x3f);
 
237
 
 
238
    return 4;
 
239
  }
 
240
  else if (ucs4 <= 0x03ffffffL) {
 
241
    utf8[0] = 0xf8 | ((ucs4 >> 24) & 0x03);
 
242
    utf8[1] = 0x80 | ((ucs4 >> 18) & 0x3f);
 
243
    utf8[2] = 0x80 | ((ucs4 >> 12) & 0x3f);
 
244
    utf8[3] = 0x80 | ((ucs4 >>  6) & 0x3f);
 
245
    utf8[4] = 0x80 | ((ucs4 >>  0) & 0x3f);
 
246
 
 
247
    return 5;
 
248
  }
 
249
  else if (ucs4 <= 0x7fffffffL) {
 
250
    utf8[0] = 0xfc | ((ucs4 >> 30) & 0x01);
 
251
    utf8[1] = 0x80 | ((ucs4 >> 24) & 0x3f);
 
252
    utf8[2] = 0x80 | ((ucs4 >> 18) & 0x3f);
 
253
    utf8[3] = 0x80 | ((ucs4 >> 12) & 0x3f);
 
254
    utf8[4] = 0x80 | ((ucs4 >>  6) & 0x3f);
 
255
    utf8[5] = 0x80 | ((ucs4 >>  0) & 0x3f);
 
256
 
 
257
    return 6;
 
258
  }
 
259
 
 
260
  /* default */
 
261
 
 
262
  return id3_utf8_encodechar(utf8, ID3_UCS4_REPLACEMENTCHAR);
 
263
}
 
264
 
 
265
/*
 
266
 * NAME:        utf8->decode()
 
267
 * DESCRIPTION: decode a complete utf8 string into a ucs4 string
 
268
 */
 
269
void id3_utf8_decode(id3_utf8_t const *utf8, id3_ucs4_t *ucs4)
 
270
{
 
271
  do
 
272
    utf8 += id3_utf8_decodechar(utf8, ucs4);
 
273
  while (*ucs4++);
 
274
}
 
275
 
 
276
/*
 
277
 * NAME:        utf8->encode()
 
278
 * DESCRIPTION: encode a complete ucs4 string into a utf8 string
 
279
 */
 
280
void id3_utf8_encode(id3_utf8_t *utf8, id3_ucs4_t const *ucs4)
 
281
{
 
282
  do
 
283
    utf8 += id3_utf8_encodechar(utf8, *ucs4);
 
284
  while (*ucs4++);
 
285
}
 
286
 
 
287
/*
 
288
 * NAME:        utf8->put()
 
289
 * DESCRIPTION: serialize a single utf8 character
 
290
 */
 
291
id3_length_t id3_utf8_put(id3_byte_t **ptr, id3_utf8_t utf8)
 
292
{
 
293
  if (ptr)
 
294
    *(*ptr)++ = utf8;
 
295
 
 
296
  return 1;
 
297
}
 
298
 
 
299
/*
 
300
 * NAME:        utf8->get()
 
301
 * DESCRIPTION: deserialize a single utf8 character
 
302
 */
 
303
id3_utf8_t id3_utf8_get(id3_byte_t const **ptr)
 
304
{
 
305
  return *(*ptr)++;
 
306
}
 
307
 
 
308
/*
 
309
 * NAME:        utf8->serialize()
 
310
 * DESCRIPTION: serialize a ucs4 string using utf8 encoding
 
311
 */
 
312
id3_length_t id3_utf8_serialize(id3_byte_t **ptr, id3_ucs4_t const *ucs4,
 
313
                                int terminate)
 
314
{
 
315
  id3_length_t size = 0;
 
316
  id3_utf8_t utf8[6], *out;
 
317
 
 
318
  while (*ucs4) {
 
319
    switch (id3_utf8_encodechar(out = utf8, *ucs4++)) {
 
320
    case 6: size += id3_utf8_put(ptr, *out++);
 
321
    case 5: size += id3_utf8_put(ptr, *out++);
 
322
    case 4: size += id3_utf8_put(ptr, *out++);
 
323
    case 3: size += id3_utf8_put(ptr, *out++);
 
324
    case 2: size += id3_utf8_put(ptr, *out++);
 
325
    case 1: size += id3_utf8_put(ptr, *out++);
 
326
    case 0: break;
 
327
    }
 
328
  }
 
329
 
 
330
  if (terminate)
 
331
    size += id3_utf8_put(ptr, 0);
 
332
 
 
333
  return size;
 
334
}
 
335
 
 
336
/*
 
337
 * NAME:        utf8->deserialize()
 
338
 * DESCRIPTION: deserialize a ucs4 string using utf8 encoding
 
339
 */
 
340
id3_ucs4_t *id3_utf8_deserialize(id3_byte_t const **ptr, id3_length_t length)
 
341
{
 
342
  id3_byte_t const *end;
 
343
  id3_utf8_t *utf8ptr, *utf8;
 
344
  id3_ucs4_t *ucs4;
 
345
 
 
346
  end = *ptr + length;
 
347
 
 
348
  utf8 = malloc((length + 1) * sizeof(*utf8));
 
349
  if (utf8 == 0)
 
350
    return 0;
 
351
 
 
352
  utf8ptr = utf8;
 
353
  while (end - *ptr > 0 && (*utf8ptr = id3_utf8_get(ptr)))
 
354
    ++utf8ptr;
 
355
 
 
356
  *utf8ptr = 0;
 
357
 
 
358
  ucs4 = malloc((id3_utf8_length(utf8) + 1) * sizeof(*ucs4));
 
359
  if (ucs4)
 
360
    id3_utf8_decode(utf8, ucs4);
 
361
 
 
362
  free(utf8);
 
363
 
 
364
  return ucs4;
 
365
}