[buffer] Remove wrong optimization
[profile/ivi/org.tizen.video-player.git] / src / hb-buffer.cc
1 /*
2  * Copyright © 1998-2004  David Turner and Werner Lemberg
3  * Copyright © 2004,2007,2009,2010  Red Hat, Inc.
4  * Copyright © 2011  Google, Inc.
5  *
6  *  This is part of HarfBuzz, a text shaping library.
7  *
8  * Permission is hereby granted, without written agreement and without
9  * license or royalty fees, to use, copy, modify, and distribute this
10  * software and its documentation for any purpose, provided that the
11  * above copyright notice and the following two paragraphs appear in
12  * all copies of this software.
13  *
14  * IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE TO ANY PARTY FOR
15  * DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES
16  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN
17  * IF THE COPYRIGHT HOLDER HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
18  * DAMAGE.
19  *
20  * THE COPYRIGHT HOLDER SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING,
21  * BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
22  * FITNESS FOR A PARTICULAR PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS
23  * ON AN "AS IS" BASIS, AND THE COPYRIGHT HOLDER HAS NO OBLIGATION TO
24  * PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
25  *
26  * Red Hat Author(s): Owen Taylor, Behdad Esfahbod
27  * Google Author(s): Behdad Esfahbod
28  */
29
30 #include "hb-buffer-private.hh"
31
32 #include <string.h>
33
34 HB_BEGIN_DECLS
35
36
37 static hb_buffer_t _hb_buffer_nil = {
38   HB_OBJECT_HEADER_STATIC,
39
40   &_hb_unicode_funcs_default,
41   {
42     HB_DIRECTION_INVALID,
43     HB_SCRIPT_INVALID,
44     NULL,
45   },
46
47   TRUE, /* in_error */
48   TRUE, /* have_output */
49   TRUE  /* have_positions */
50 };
51
52 /* Here is how the buffer works internally:
53  *
54  * There are two info pointers: info and out_info.  They always have
55  * the same allocated size, but different lengths.
56  *
57  * As an optimization, both info and out_info may point to the
58  * same piece of memory, which is owned by info.  This remains the
59  * case as long as out_len doesn't exceed i at any time.
60  * In that case, swap() is no-op and the glyph operations operate
61  * mostly in-place.
62  *
63  * As soon as out_info gets longer than info, out_info is moved over
64  * to an alternate buffer (which we reuse the pos buffer for!), and its
65  * current contents (out_len entries) are copied to the new place.
66  * This should all remain transparent to the user.  swap() then
67  * switches info and out_info.
68  */
69
70
71 static hb_bool_t
72 _hb_buffer_enlarge (hb_buffer_t *buffer, unsigned int size)
73 {
74   if (unlikely (buffer->in_error))
75     return FALSE;
76
77   unsigned int new_allocated = buffer->allocated;
78   hb_glyph_position_t *new_pos = NULL;
79   hb_glyph_info_t *new_info = NULL;
80   bool separate_out = buffer->out_info != buffer->info;
81
82   if (unlikely (_hb_unsigned_int_mul_overflows (size, sizeof (buffer->info[0]))))
83     goto done;
84
85   while (size > new_allocated)
86     new_allocated += (new_allocated >> 1) + 32;
87
88   ASSERT_STATIC (sizeof (buffer->info[0]) == sizeof (buffer->pos[0]));
89   if (unlikely (_hb_unsigned_int_mul_overflows (new_allocated, sizeof (buffer->info[0]))))
90     goto done;
91
92   new_pos = (hb_glyph_position_t *) realloc (buffer->pos, new_allocated * sizeof (buffer->pos[0]));
93   new_info = (hb_glyph_info_t *) realloc (buffer->info, new_allocated * sizeof (buffer->info[0]));
94
95 done:
96   if (unlikely (!new_pos || !new_info))
97     buffer->in_error = TRUE;
98
99   if (likely (new_pos))
100     buffer->pos = new_pos;
101
102   if (likely (new_info))
103     buffer->info = new_info;
104
105   buffer->out_info = separate_out ? (hb_glyph_info_t *) buffer->pos : buffer->info;
106   if (likely (!buffer->in_error))
107     buffer->allocated = new_allocated;
108
109   return likely (!buffer->in_error);
110 }
111
112 static inline hb_bool_t
113 _hb_buffer_ensure (hb_buffer_t *buffer, unsigned int size)
114 {
115   return likely (size <= buffer->allocated) ? TRUE : _hb_buffer_enlarge (buffer, size);
116 }
117
118 static inline hb_bool_t
119 _hb_buffer_ensure_separate (hb_buffer_t *buffer, unsigned int size)
120 {
121   if (unlikely (!size || !_hb_buffer_ensure (buffer, size))) return FALSE;
122
123   if (buffer->out_info == buffer->info)
124   {
125     assert (buffer->have_output);
126
127     buffer->out_info = (hb_glyph_info_t *) buffer->pos;
128     memcpy (buffer->out_info, buffer->info, buffer->out_len * sizeof (buffer->out_info[0]));
129   }
130
131   return TRUE;
132 }
133
134
135 /* Public API */
136
137 hb_buffer_t *
138 hb_buffer_create (unsigned int pre_alloc_size)
139 {
140   hb_buffer_t *buffer;
141
142   if (!(buffer = hb_object_create<hb_buffer_t> ()))
143     return &_hb_buffer_nil;
144
145   hb_buffer_reset (buffer);
146
147   if (pre_alloc_size && !_hb_buffer_ensure (buffer, pre_alloc_size)) {
148     hb_buffer_destroy (buffer);
149     return &_hb_buffer_nil;
150   }
151
152   return buffer;
153 }
154
155 hb_buffer_t *
156 hb_buffer_reference (hb_buffer_t *buffer)
157 {
158   return hb_object_reference (buffer);
159 }
160
161 void
162 hb_buffer_destroy (hb_buffer_t *buffer)
163 {
164   if (!hb_object_destroy (buffer)) return;
165
166   hb_unicode_funcs_destroy (buffer->unicode);
167
168   free (buffer->info);
169   free (buffer->pos);
170
171   free (buffer);
172 }
173
174 hb_bool_t
175 hb_buffer_set_user_data (hb_buffer_t        *buffer,
176                          hb_user_data_key_t *key,
177                          void *              data,
178                          hb_destroy_func_t   destroy)
179 {
180   return hb_object_set_user_data (buffer, key, data, destroy);
181 }
182
183 void *
184 hb_buffer_get_user_data (hb_buffer_t        *buffer,
185                          hb_user_data_key_t *key)
186 {
187   return hb_object_get_user_data (buffer, key);
188 }
189
190
191 void
192 hb_buffer_set_unicode_funcs (hb_buffer_t        *buffer,
193                              hb_unicode_funcs_t *unicode)
194 {
195   if (unlikely (hb_object_is_inert (buffer)))
196     return;
197
198   if (!unicode)
199     unicode = _hb_buffer_nil.unicode;
200
201   hb_unicode_funcs_reference (unicode);
202   hb_unicode_funcs_destroy (buffer->unicode);
203   buffer->unicode = unicode;
204 }
205
206 hb_unicode_funcs_t *
207 hb_buffer_get_unicode_funcs (hb_buffer_t        *buffer)
208 {
209   return buffer->unicode;
210 }
211
212 void
213 hb_buffer_set_direction (hb_buffer_t    *buffer,
214                          hb_direction_t  direction)
215
216 {
217   if (unlikely (hb_object_is_inert (buffer)))
218     return;
219
220   buffer->props.direction = direction;
221 }
222
223 hb_direction_t
224 hb_buffer_get_direction (hb_buffer_t    *buffer)
225 {
226   return buffer->props.direction;
227 }
228
229 void
230 hb_buffer_set_script (hb_buffer_t *buffer,
231                       hb_script_t  script)
232 {
233   if (unlikely (hb_object_is_inert (buffer)))
234     return;
235
236   buffer->props.script = script;
237 }
238
239 hb_script_t
240 hb_buffer_get_script (hb_buffer_t *buffer)
241 {
242   return buffer->props.script;
243 }
244
245 void
246 hb_buffer_set_language (hb_buffer_t   *buffer,
247                         hb_language_t  language)
248 {
249   if (unlikely (hb_object_is_inert (buffer)))
250     return;
251
252   buffer->props.language = language;
253 }
254
255 hb_language_t
256 hb_buffer_get_language (hb_buffer_t *buffer)
257 {
258   return buffer->props.language;
259 }
260
261
262 void
263 hb_buffer_reset (hb_buffer_t *buffer)
264 {
265   if (unlikely (hb_object_is_inert (buffer)))
266     return;
267
268   hb_unicode_funcs_destroy (buffer->unicode);
269   buffer->unicode = _hb_buffer_nil.unicode;
270
271   buffer->props = _hb_buffer_nil.props;
272
273   buffer->in_error = FALSE;
274   buffer->have_output = FALSE;
275   buffer->have_positions = FALSE;
276
277   buffer->i = 0;
278   buffer->len = 0;
279   buffer->out_len = 0;
280
281   buffer->serial = 0;
282
283   buffer->out_info = buffer->info;
284 }
285
286 hb_bool_t
287 hb_buffer_pre_allocate (hb_buffer_t *buffer, unsigned int size)
288 {
289   return _hb_buffer_ensure (buffer, size);
290 }
291
292 hb_bool_t
293 hb_buffer_allocation_successful (hb_buffer_t  *buffer)
294 {
295   return !buffer->in_error;
296 }
297
298 void
299 hb_buffer_add (hb_buffer_t    *buffer,
300                hb_codepoint_t  codepoint,
301                hb_mask_t       mask,
302                unsigned int    cluster)
303 {
304   hb_glyph_info_t *glyph;
305
306   if (unlikely (!_hb_buffer_ensure (buffer, buffer->len + 1))) return;
307
308   glyph = &buffer->info[buffer->len];
309
310   memset (glyph, 0, sizeof (*glyph));
311   glyph->codepoint = codepoint;
312   glyph->mask = mask;
313   glyph->cluster = cluster;
314
315   buffer->len++;
316 }
317
318 /* HarfBuzz-Internal API */
319
320 void
321 _hb_buffer_clear_output (hb_buffer_t *buffer)
322 {
323   if (unlikely (hb_object_is_inert (buffer)))
324     return;
325
326   buffer->have_output = TRUE;
327   buffer->have_positions = FALSE;
328
329   buffer->out_len = 0;
330   buffer->out_info = buffer->info;
331 }
332
333 void
334 _hb_buffer_clear_positions (hb_buffer_t *buffer)
335 {
336   if (unlikely (hb_object_is_inert (buffer)))
337     return;
338
339   buffer->have_output = FALSE;
340   buffer->have_positions = TRUE;
341
342   memset (buffer->pos, 0, sizeof (buffer->pos[0]) * buffer->len);
343 }
344
345 void
346 _hb_buffer_swap (hb_buffer_t *buffer)
347 {
348   if (unlikely (buffer->in_error)) return;
349
350   assert (buffer->have_output);
351
352   if (buffer->out_info != buffer->info)
353   {
354     hb_glyph_info_t *tmp_string;
355     tmp_string = buffer->info;
356     buffer->info = buffer->out_info;
357     buffer->out_info = tmp_string;
358     buffer->pos = (hb_glyph_position_t *) buffer->out_info;
359   }
360
361   unsigned int tmp;
362   tmp = buffer->len;
363   buffer->len = buffer->out_len;
364   buffer->out_len = tmp;
365
366   buffer->i = 0;
367 }
368
369 void
370 _hb_buffer_replace_glyphs_be16 (hb_buffer_t *buffer,
371                                 unsigned int num_in,
372                                 unsigned int num_out,
373                                 const uint16_t *glyph_data_be)
374 {
375   if (buffer->out_info != buffer->info ||
376       buffer->out_len + num_out > buffer->i + num_in)
377   {
378     if (unlikely (!_hb_buffer_ensure_separate (buffer, buffer->out_len + num_out)))
379       return;
380   }
381
382   hb_glyph_info_t orig_info = buffer->info[buffer->i];
383
384   for (unsigned int i = 0; i < num_out; i++)
385   {
386     hb_glyph_info_t *info = &buffer->out_info[buffer->out_len + i];
387     *info = orig_info;
388     info->codepoint = hb_be_uint16 (glyph_data_be[i]);
389   }
390
391   buffer->i  += num_in;
392   buffer->out_len += num_out;
393 }
394
395 void
396 _hb_buffer_replace_glyph (hb_buffer_t *buffer,
397                           hb_codepoint_t glyph_index)
398 {
399   hb_glyph_info_t *info;
400
401   if (buffer->out_info != buffer->info)
402   {
403     if (unlikely (!_hb_buffer_ensure (buffer, buffer->out_len + 1))) return;
404     buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
405   }
406   else if (buffer->out_len != buffer->i)
407     buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
408
409   info = &buffer->out_info[buffer->out_len];
410   info->codepoint = glyph_index;
411
412   buffer->i++;
413   buffer->out_len++;
414 }
415
416 void
417 _hb_buffer_next_glyph (hb_buffer_t *buffer)
418 {
419   if (buffer->have_output)
420   {
421     if (buffer->out_info != buffer->info)
422     {
423       if (unlikely (!_hb_buffer_ensure (buffer, buffer->out_len + 1))) return;
424       buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
425     }
426     else if (buffer->out_len != buffer->i)
427       buffer->out_info[buffer->out_len] = buffer->info[buffer->i];
428
429     buffer->out_len++;
430   }
431
432   buffer->i++;
433 }
434
435 void
436 _hb_buffer_reset_masks (hb_buffer_t *buffer,
437                         hb_mask_t    mask)
438 {
439   unsigned int count = buffer->len;
440   for (unsigned int i = 0; i < count; i++)
441     buffer->info[i].mask = mask;
442 }
443
444 void
445 _hb_buffer_add_masks (hb_buffer_t *buffer,
446                       hb_mask_t    mask)
447 {
448   unsigned int count = buffer->len;
449   for (unsigned int i = 0; i < count; i++)
450     buffer->info[i].mask |= mask;
451 }
452
453 void
454 _hb_buffer_set_masks (hb_buffer_t *buffer,
455                       hb_mask_t    value,
456                       hb_mask_t    mask,
457                       unsigned int cluster_start,
458                       unsigned int cluster_end)
459 {
460   hb_mask_t not_mask = ~mask;
461   value &= mask;
462
463   if (!mask)
464     return;
465
466   if (cluster_start == 0 && cluster_end == (unsigned int)-1) {
467     unsigned int count = buffer->len;
468     for (unsigned int i = 0; i < count; i++)
469       buffer->info[i].mask = (buffer->info[i].mask & not_mask) | value;
470     return;
471   }
472
473   unsigned int count = buffer->len;
474   for (unsigned int i = 0; i < count; i++)
475     if (cluster_start <= buffer->info[i].cluster && buffer->info[i].cluster < cluster_end)
476       buffer->info[i].mask = (buffer->info[i].mask & not_mask) | value;
477 }
478
479
480 /* Public API again */
481
482 hb_bool_t
483 hb_buffer_set_length (hb_buffer_t  *buffer,
484                       unsigned int  length)
485 {
486   if (!_hb_buffer_ensure (buffer, length))
487     return FALSE;
488
489   /* Wipe the new space */
490   if (length > buffer->len) {
491     memset (buffer->info + buffer->len, 0, sizeof (buffer->info[0]) * (length - buffer->len));
492     if (buffer->have_positions)
493       memset (buffer->pos + buffer->len, 0, sizeof (buffer->pos[0]) * (length - buffer->len));
494   }
495
496   buffer->len = length;
497   return TRUE;
498 }
499
500 unsigned int
501 hb_buffer_get_length (hb_buffer_t *buffer)
502 {
503   return buffer->len;
504 }
505
506 /* Return value valid as long as buffer not modified */
507 hb_glyph_info_t *
508 hb_buffer_get_glyph_infos (hb_buffer_t  *buffer,
509                            unsigned int *length)
510 {
511   if (length)
512     *length = buffer->len;
513
514   return (hb_glyph_info_t *) buffer->info;
515 }
516
517 /* Return value valid as long as buffer not modified */
518 hb_glyph_position_t *
519 hb_buffer_get_glyph_positions (hb_buffer_t  *buffer,
520                                unsigned int *length)
521 {
522   if (!buffer->have_positions)
523     _hb_buffer_clear_positions (buffer);
524
525   if (length)
526     *length = buffer->len;
527
528   return (hb_glyph_position_t *) buffer->pos;
529 }
530
531
532 static void
533 reverse_range (hb_buffer_t *buffer,
534                unsigned int start,
535                unsigned int end)
536 {
537   unsigned int i, j;
538
539   for (i = start, j = end - 1; i < j; i++, j--) {
540     hb_glyph_info_t t;
541
542     t = buffer->info[i];
543     buffer->info[i] = buffer->info[j];
544     buffer->info[j] = t;
545   }
546
547   if (buffer->pos) {
548     for (i = 0, j = end - 1; i < j; i++, j--) {
549       hb_glyph_position_t t;
550
551       t = buffer->pos[i];
552       buffer->pos[i] = buffer->pos[j];
553       buffer->pos[j] = t;
554     }
555   }
556 }
557
558 void
559 hb_buffer_reverse (hb_buffer_t *buffer)
560 {
561   if (unlikely (!buffer->len))
562     return;
563
564   reverse_range (buffer, 0, buffer->len);
565 }
566
567 void
568 hb_buffer_reverse_clusters (hb_buffer_t *buffer)
569 {
570   unsigned int i, start, count, last_cluster;
571
572   if (unlikely (!buffer->len))
573     return;
574
575   hb_buffer_reverse (buffer);
576
577   count = buffer->len;
578   start = 0;
579   last_cluster = buffer->info[0].cluster;
580   for (i = 1; i < count; i++) {
581     if (last_cluster != buffer->info[i].cluster) {
582       reverse_range (buffer, start, i);
583       start = i;
584       last_cluster = buffer->info[i].cluster;
585     }
586   }
587   reverse_range (buffer, start, i);
588 }
589
590
591 #define ADD_UTF(T) \
592         HB_STMT_START { \
593           const T *next = (const T *) text + item_offset; \
594           const T *end = next + item_length; \
595           while (next < end) { \
596             hb_codepoint_t u; \
597             const T *old_next = next; \
598             next = UTF_NEXT (next, end, u); \
599             hb_buffer_add (buffer, u, 1,  old_next - (const T *) text); \
600           } \
601         } HB_STMT_END
602
603
604 #define UTF8_COMPUTE(Char, Mask, Len) \
605   if (Char < 128) { Len = 1; Mask = 0x7f; } \
606   else if ((Char & 0xe0) == 0xc0) { Len = 2; Mask = 0x1f; } \
607   else if ((Char & 0xf0) == 0xe0) { Len = 3; Mask = 0x0f; } \
608   else if ((Char & 0xf8) == 0xf0) { Len = 4; Mask = 0x07; } \
609   else Len = 0;
610
611 static inline const uint8_t *
612 hb_utf8_next (const uint8_t *text,
613               const uint8_t *end,
614               hb_codepoint_t *unicode)
615 {
616   uint8_t c = *text;
617   unsigned int mask, len;
618
619   /* TODO check for overlong sequences? */
620
621   UTF8_COMPUTE (c, mask, len);
622   if (unlikely (!len || (unsigned int) (end - text) < len)) {
623     *unicode = -1;
624     return text + 1;
625   } else {
626     hb_codepoint_t result;
627     unsigned int i;
628     result = c & mask;
629     for (i = 1; i < len; i++)
630       {
631         if (unlikely ((text[i] & 0xc0) != 0x80))
632           {
633             *unicode = -1;
634             return text + 1;
635           }
636         result <<= 6;
637         result |= (text[i] & 0x3f);
638       }
639     *unicode = result;
640     return text + len;
641   }
642 }
643
644 void
645 hb_buffer_add_utf8 (hb_buffer_t  *buffer,
646                     const char   *text,
647                     unsigned int  text_length HB_UNUSED,
648                     unsigned int  item_offset,
649                     unsigned int  item_length)
650 {
651 #define UTF_NEXT(S, E, U)       hb_utf8_next (S, E, &(U))
652   ADD_UTF (uint8_t);
653 #undef UTF_NEXT
654 }
655
656 static inline const uint16_t *
657 hb_utf16_next (const uint16_t *text,
658                const uint16_t *end,
659                hb_codepoint_t *unicode)
660 {
661   uint16_t c = *text++;
662
663   if (unlikely (c >= 0xd800 && c < 0xdc00)) {
664     /* high surrogate */
665     uint16_t l;
666     if (text < end && ((l = *text), likely (l >= 0xdc00 && l < 0xe000))) {
667       /* low surrogate */
668       *unicode = ((hb_codepoint_t) ((c) - 0xd800) * 0x400 + (l) - 0xdc00 + 0x10000);
669        text++;
670     } else
671       *unicode = -1;
672   } else
673     *unicode = c;
674
675   return text;
676 }
677
678 void
679 hb_buffer_add_utf16 (hb_buffer_t    *buffer,
680                      const uint16_t *text,
681                      unsigned int    text_length HB_UNUSED,
682                      unsigned int    item_offset,
683                      unsigned int    item_length)
684 {
685 #define UTF_NEXT(S, E, U)       hb_utf16_next (S, E, &(U))
686   ADD_UTF (uint16_t);
687 #undef UTF_NEXT
688 }
689
690 void
691 hb_buffer_add_utf32 (hb_buffer_t    *buffer,
692                      const uint32_t *text,
693                      unsigned int    text_length HB_UNUSED,
694                      unsigned int    item_offset,
695                      unsigned int    item_length)
696 {
697 #define UTF_NEXT(S, E, U)       ((U) = *(S), (S)+1)
698   ADD_UTF (uint32_t);
699 #undef UTF_NEXT
700 }
701
702
703 HB_END_DECLS