utils.c

   1 /*****************************************************************************
   2  * utils.c:
   3  *****************************************************************************
   4  * Copyright (C) 2010-2012 L-SMASH project
   5  *
   6  * Authors: Yusuke Nakamura <muken.the.vfrmaniac@gmail.com>
   7  *
   8  * Permission to use, copy, modify, and/or distribute this software for any
   9  * purpose with or without fee is hereby granted, provided that the above
  10  * copyright notice and this permission notice appear in all copies.
  11  *
  12  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  13  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  14  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  15  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  16  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  17  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  18  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  19  *****************************************************************************/
  20
  21 /* This file is available under an ISC license. */
  22
  23 #include "internal.h" /* must be placed first */
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28
  29 #include "utils.h"
  30
  31 uint64_t lsmash_bs_get_pos( lsmash_bs_t *bs )
  32 {
  33     return bs->pos;
  34 }
  35
  36 void lsmash_bs_empty( lsmash_bs_t *bs )
  37 {
  38     if( !bs )
  39         return;
  40     memset( bs->data, 0, bs->alloc );
  41     bs->store = 0;
  42     bs->pos = 0;
  43 }
  44
  45 void lsmash_bs_free( lsmash_bs_t *bs )
  46 {
  47     if( bs->data )
  48         free( bs->data );
  49     bs->data = NULL;
  50     bs->alloc = 0;
  51     bs->store = 0;
  52     bs->pos = 0;
  53 }
  54
  55 void lsmash_bs_alloc( lsmash_bs_t *bs, uint64_t size )
  56 {
  57     if( (bs->alloc >= size) || bs->error )
  58         return;
  59     uint64_t alloc = size + (1<<16);
  60     uint8_t *data;
  61     if( !bs->data )
  62         data = malloc( alloc );
  63     else
  64         data = realloc( bs->data, alloc );
  65     if( !data )
  66     {
  67         lsmash_bs_free( bs );
  68         bs->error = 1;
  69         return;
  70     }
  71     bs->data  = data;
  72     bs->alloc = alloc;
  73 }
  74
  75 /*---- bitstream writer ----*/
  76 void lsmash_bs_put_byte( lsmash_bs_t *bs, uint8_t value )
  77 {
  78     lsmash_bs_alloc( bs, bs->store + 1 );
  79     if( bs->error )
  80         return;
  81     bs->data[bs->store ++] = value;
  82 }
  83
  84 void lsmash_bs_put_bytes( lsmash_bs_t *bs, uint32_t size, void *value )
  85 {
  86     if( !size || !value )
  87         return;
  88     lsmash_bs_alloc( bs, bs->store + size );
  89     if( bs->error )
  90         return;
  91     memcpy( bs->data + bs->store, value, size );
  92     bs->store += size;
  93 }
  94
  95 void lsmash_bs_put_be16( lsmash_bs_t *bs, uint16_t value )
  96 {
  97     lsmash_bs_put_byte( bs, (uint8_t)((value>>8)&0xff) );
  98     lsmash_bs_put_byte( bs, (uint8_t)(value&0xff) );
  99 }
 100
 101 void lsmash_bs_put_be24( lsmash_bs_t *bs, uint32_t value )
 102 {
 103     lsmash_bs_put_byte( bs, (uint8_t)((value>>16)&0xff) );
 104     lsmash_bs_put_be16( bs, (uint16_t)(value&0xffff) );
 105 }
 106
 107 void lsmash_bs_put_be32( lsmash_bs_t *bs, uint32_t value )
 108 {
 109     lsmash_bs_put_be16( bs, (uint16_t)((value>>16)&0xffff) );
 110     lsmash_bs_put_be16( bs, (uint16_t)(value&0xffff) );
 111 }
 112
 113 void lsmash_bs_put_be64( lsmash_bs_t *bs, uint64_t value )
 114 {
 115     lsmash_bs_put_be32( bs, (uint32_t)((value>>32)&0xffffffff) );
 116     lsmash_bs_put_be32( bs, (uint32_t)(value&0xffffffff) );
 117 }
 118
 119 void lsmash_bs_put_byte_from_64( lsmash_bs_t *bs, uint64_t value )
 120 {
 121     lsmash_bs_put_byte( bs, (uint8_t)(value&0xff) );
 122 }
 123
 124 void lsmash_bs_put_be16_from_64( lsmash_bs_t *bs, uint64_t value )
 125 {
 126     lsmash_bs_put_be16( bs, (uint16_t)(value&0xffff) );
 127 }
 128
 129 void lsmash_bs_put_be24_from_64( lsmash_bs_t *bs, uint64_t value )
 130 {
 131     lsmash_bs_put_be24( bs, (uint32_t)(value&0xffffff) );
 132 }
 133
 134 void lsmash_bs_put_be32_from_64( lsmash_bs_t *bs, uint64_t value )
 135 {
 136     lsmash_bs_put_be32( bs, (uint32_t)(value&0xffffffff) );
 137 }
 138
 139 int lsmash_bs_write_data( lsmash_bs_t *bs )
 140 {
 141     if( !bs )
 142         return -1;
 143     if( !bs->store || !bs->data )
 144         return 0;
 145     if( bs->error || !bs->stream || fwrite( bs->data, 1, bs->store, bs->stream ) != bs->store )
 146     {
 147         lsmash_bs_free( bs );
 148         bs->error = 1;
 149         return -1;
 150     }
 151     bs->written += bs->store;
 152     bs->store = 0;
 153     return 0;
 154 }
 155
 156 lsmash_bs_t* lsmash_bs_create( char* filename )
 157 {
 158     lsmash_bs_t* bs = lsmash_malloc_zero( sizeof(lsmash_bs_t) );
 159     if( !bs )
 160         return NULL;
 161     if( filename && (bs->stream = fopen( filename, "wb" )) == NULL )
 162     {
 163         free( bs );
 164         return NULL;
 165     }
 166     return bs;
 167 }
 168
 169 void lsmash_bs_cleanup( lsmash_bs_t *bs )
 170 {
 171     if( !bs )
 172         return;
 173     if( bs->stream )
 174         fclose( bs->stream );
 175     lsmash_bs_free( bs );
 176     free( bs );
 177 }
 178
 179 void* lsmash_bs_export_data( lsmash_bs_t *bs, uint32_t* length )
 180 {
 181     if( !bs || !bs->data || bs->store == 0 || bs->error )
 182         return NULL;
 183     void *buf = lsmash_memdup( bs->data, bs->store );
 184     if( !buf )
 185         return NULL;
 186     if( length )
 187         *length = bs->store;
 188     return buf;
 189 }
 190 /*---- ----*/
 191
 192 /*---- bitstream reader ----*/
 193 uint8_t lsmash_bs_show_byte( lsmash_bs_t *bs, uint32_t offset )
 194 {
 195     if( bs->error || !bs->data )
 196         return 0;
 197     if( bs->pos + offset > bs->store )
 198     {
 199         lsmash_bs_free( bs );
 200         bs->error = 1;
 201         return 0;
 202     }
 203     return bs->data[bs->pos + offset];
 204 }
 205
 206 uint8_t lsmash_bs_get_byte( lsmash_bs_t *bs )
 207 {
 208     if( bs->error || !bs->data )
 209         return 0;
 210     if( bs->pos + 1 > bs->store )
 211     {
 212         lsmash_bs_free( bs );
 213         bs->error = 1;
 214         return 0;
 215     }
 216     return bs->data[bs->pos ++];
 217 }
 218
 219 uint8_t *lsmash_bs_get_bytes( lsmash_bs_t *bs, uint32_t size )
 220 {
 221     if( bs->error || !size )
 222         return NULL;
 223     if( bs->pos + size > bs->store )
 224     {
 225         lsmash_bs_free( bs );
 226         bs->error = 1;
 227         return NULL;
 228     }
 229     uint8_t *value = lsmash_memdup( bs->data + bs->pos, size );
 230     if( !value )
 231     {
 232         lsmash_bs_free( bs );
 233         bs->error = 1;
 234         return NULL;
 235     }
 236     bs->pos += size;
 237     return value;
 238 }
 239
 240 uint16_t lsmash_bs_get_be16( lsmash_bs_t *bs )
 241 {
 242     uint16_t    value = lsmash_bs_get_byte( bs );
 243     return (value<<8) | lsmash_bs_get_byte( bs );
 244 }
 245
 246 uint32_t lsmash_bs_get_be24( lsmash_bs_t *bs )
 247 {
 248     uint32_t     value = lsmash_bs_get_byte( bs );
 249     return (value<<16) | lsmash_bs_get_be16( bs );
 250 }
 251
 252 uint32_t lsmash_bs_get_be32( lsmash_bs_t *bs )
 253 {
 254     uint32_t     value = lsmash_bs_get_be16( bs );
 255     return (value<<16) | lsmash_bs_get_be16( bs );
 256 }
 257
 258 uint64_t lsmash_bs_get_be64( lsmash_bs_t *bs )
 259 {
 260     uint64_t     value = lsmash_bs_get_be32( bs );
 261     return (value<<32) | lsmash_bs_get_be32( bs );
 262 }
 263
 264 uint64_t lsmash_bs_get_byte_to_64( lsmash_bs_t *bs )
 265 {
 266     return lsmash_bs_get_byte( bs );
 267 }
 268
 269 uint64_t lsmash_bs_get_be16_to_64( lsmash_bs_t *bs )
 270 {
 271     return lsmash_bs_get_be16( bs );
 272 }
 273
 274 uint64_t lsmash_bs_get_be24_to_64( lsmash_bs_t *bs )
 275 {
 276     return lsmash_bs_get_be24( bs );
 277 }
 278
 279 uint64_t lsmash_bs_get_be32_to_64( lsmash_bs_t *bs )
 280 {
 281     return lsmash_bs_get_be32( bs );
 282 }
 283
 284 int lsmash_bs_read_data( lsmash_bs_t *bs, uint32_t size )
 285 {
 286     if( !bs )
 287         return -1;
 288     if( !size )
 289         return 0;
 290     lsmash_bs_alloc( bs, bs->store + size );
 291     if( bs->error || !bs->stream )
 292     {
 293         lsmash_bs_free( bs );
 294         bs->error = 1;
 295         return -1;
 296     }
 297     uint64_t read_size = fread( bs->data + bs->store, 1, size, bs->stream );
 298     if( read_size != size && !feof( bs->stream ) )
 299     {
 300         bs->error = 1;
 301         return -1;
 302     }
 303     bs->store += read_size;
 304     return 0;
 305 }
 306
 307 int lsmash_bs_import_data( lsmash_bs_t *bs, void* data, uint32_t length )
 308 {
 309     if( !bs || bs->error || !data || length == 0 )
 310         return -1;
 311     lsmash_bs_alloc( bs, bs->store + length );
 312     if( bs->error || !bs->data ) /* means, failed to alloc. */
 313     {
 314         lsmash_bs_free( bs );
 315         return -1;
 316     }
 317     memcpy( bs->data + bs->store, data, length );
 318     bs->store += length;
 319     return 0;
 320 }
 321 /*---- ----*/
 322
 323 /*---- bitstream ----*/
 324 void lsmash_bits_init( lsmash_bits_t *bits, lsmash_bs_t *bs )
 325 {
 326     debug_if( !bits || !bs )
 327         return;
 328     bits->bs = bs;
 329     bits->store = 0;
 330     bits->cache = 0;
 331 }
 332
 333 lsmash_bits_t *lsmash_bits_create( lsmash_bs_t *bs )
 334 {
 335     debug_if( !bs )
 336         return NULL;
 337     lsmash_bits_t *bits = (lsmash_bits_t *)malloc( sizeof(lsmash_bits_t) );
 338     if( !bits )
 339         return NULL;
 340     lsmash_bits_init( bits, bs );
 341     return bits;
 342 }
 343
 344 void lsmash_bits_empty( lsmash_bits_t *bits )
 345 {
 346     debug_if( !bits )
 347         return;
 348     lsmash_bs_empty( bits->bs );
 349     bits->store = 0;
 350     bits->cache = 0;
 351 }
 352
 353 #define BITS_IN_BYTE 8
 354 void lsmash_bits_put_align( lsmash_bits_t *bits )
 355 {
 356     debug_if( !bits )
 357         return;
 358     if( !bits->store )
 359         return;
 360     lsmash_bs_put_byte( bits->bs, bits->cache << ( BITS_IN_BYTE - bits->store ) );
 361 }
 362
 363 void lsmash_bits_get_align( lsmash_bits_t *bits )
 364 {
 365     debug_if( !bits )
 366         return;
 367     bits->store = 0;
 368     bits->cache = 0;
 369 }
 370
 371 /* Must be used ONLY for bits struct created with isom_create_bits.
 372    Otherwise, just free() the bits struct. */
 373 void lsmash_bits_cleanup( lsmash_bits_t *bits )
 374 {
 375     debug_if( !bits )
 376         return;
 377     free( bits );
 378 }
 379
 380 /* we can change value's type to unsigned int for 64-bit operation if needed. */
 381 static inline uint8_t lsmash_bits_mask_lsb8( uint32_t value, uint32_t width )
 382 {
 383     return (uint8_t)( value & ~( ~0U << width ) );
 384 }
 385
 386 /* We can change value's type to unsigned int for 64-bit operation if needed. */
 387 void lsmash_bits_put( lsmash_bits_t *bits, uint32_t width, uint32_t value )
 388 {
 389     debug_if( !bits || !width )
 390         return;
 391     if( bits->store )
 392     {
 393         if( bits->store + width < BITS_IN_BYTE )
 394         {
 395             /* cache can contain all of value's bits. */
 396             bits->cache <<= width;
 397             bits->cache |= lsmash_bits_mask_lsb8( value, width );
 398             bits->store += width;
 399             return;
 400         }
 401         /* flush cache with value's some leading bits. */
 402         uint32_t free_bits = BITS_IN_BYTE - bits->store;
 403         bits->cache <<= free_bits;
 404         bits->cache |= lsmash_bits_mask_lsb8( value >> (width -= free_bits), free_bits );
 405         lsmash_bs_put_byte( bits->bs, bits->cache );
 406         bits->store = 0;
 407         bits->cache = 0;
 408     }
 409     /* cache is empty here. */
 410     /* byte unit operation. */
 411     while( width > BITS_IN_BYTE )
 412         lsmash_bs_put_byte( bits->bs, (uint8_t)(value >> (width -= BITS_IN_BYTE)) );
 413     /* bit unit operation for residual. */
 414     if( width )
 415     {
 416         bits->cache = lsmash_bits_mask_lsb8( value, width );
 417         bits->store = width;
 418     }
 419 }
 420
 421 /* We can change value's type to unsigned int for 64-bit operation if needed. */
 422 uint32_t lsmash_bits_get( lsmash_bits_t *bits, uint32_t width )
 423 {
 424     debug_if( !bits || !width )
 425         return 0;
 426     uint32_t value = 0;
 427     if( bits->store )
 428     {
 429         if( bits->store >= width )
 430         {
 431             /* cache contains all of bits required. */
 432             bits->store -= width;
 433             return lsmash_bits_mask_lsb8( bits->cache >> bits->store, width );
 434         }
 435         /* fill value's leading bits with cache's residual. */
 436         value = lsmash_bits_mask_lsb8( bits->cache, bits->store );
 437         width -= bits->store;
 438         bits->store = 0;
 439         bits->cache = 0;
 440     }
 441     /* cache is empty here. */
 442     /* byte unit operation. */
 443     while( width > BITS_IN_BYTE )
 444     {
 445         value <<= BITS_IN_BYTE;
 446         width -= BITS_IN_BYTE;
 447         value |= lsmash_bs_get_byte( bits->bs );
 448     }
 449     /* bit unit operation for residual. */
 450     if( width )
 451     {
 452         bits->cache = lsmash_bs_get_byte( bits->bs );
 453         bits->store = BITS_IN_BYTE - width;
 454         value <<= width;
 455         value |= lsmash_bits_mask_lsb8( bits->cache >> bits->store, width );
 456     }
 457     return value;
 458 }
 459
 460 /****
 461  bitstream with bytestream for adhoc operation
 462 ****/
 463
 464 lsmash_bits_t* lsmash_bits_adhoc_create()
 465 {
 466     lsmash_bs_t* bs = lsmash_bs_create( NULL ); /* no file writing */
 467     if( !bs )
 468         return NULL;
 469     lsmash_bits_t* bits = lsmash_bits_create( bs );
 470     if( !bits )
 471     {
 472         lsmash_bs_cleanup( bs );
 473         return NULL;
 474     }
 475     return bits;
 476 }
 477
 478 void lsmash_bits_adhoc_cleanup( lsmash_bits_t* bits )
 479 {
 480     if( !bits )
 481         return;
 482     lsmash_bs_cleanup( bits->bs );
 483     lsmash_bits_cleanup( bits );
 484 }
 485
 486 void* lsmash_bits_export_data( lsmash_bits_t* bits, uint32_t* length )
 487 {
 488     lsmash_bits_put_align( bits );
 489     return lsmash_bs_export_data( bits->bs, length );
 490 }
 491
 492 int lsmash_bits_import_data( lsmash_bits_t* bits, void* data, uint32_t length )
 493 {
 494     return lsmash_bs_import_data( bits->bs, data, length );
 495 }
 496 /*---- ----*/
 497
 498 /*---- list ----*/
 499 void lsmash_init_entry_list( lsmash_entry_list_t *list )
 500 {
 501     list->head = NULL;
 502     list->tail = NULL;
 503     list->last_accessed_entry = NULL;
 504     list->last_accessed_number = 0;
 505     list->entry_count = 0;
 506 }
 507
 508 lsmash_entry_list_t *lsmash_create_entry_list( void )
 509 {
 510     lsmash_entry_list_t *list = malloc( sizeof(lsmash_entry_list_t) );
 511     if( !list )
 512         return NULL;
 513     lsmash_init_entry_list( list );
 514     return list;
 515 }
 516
 517 int lsmash_add_entry( lsmash_entry_list_t *list, void *data )
 518 {
 519     if( !list )
 520         return -1;
 521     lsmash_entry_t *entry = malloc( sizeof(lsmash_entry_t) );
 522     if( !entry )
 523         return -1;
 524     entry->next = NULL;
 525     entry->prev = list->tail;
 526     entry->data = data;
 527     if( list->head )
 528         list->tail->next = entry;
 529     else
 530         list->head = entry;
 531     list->tail = entry;
 532     list->entry_count += 1;
 533     return 0;
 534 }
 535
 536 int lsmash_remove_entry_direct( lsmash_entry_list_t *list, lsmash_entry_t *entry, void* eliminator )
 537 {
 538     if( !entry )
 539         return -1;
 540     if( !eliminator )
 541         eliminator = free;
 542     lsmash_entry_t *next = entry->next;
 543     lsmash_entry_t *prev = entry->prev;
 544     if( entry == list->head )
 545         list->head = next;
 546     else
 547         prev->next = next;
 548     if( entry == list->tail )
 549         list->tail = prev;
 550     else
 551         next->prev = prev;
 552     if( entry->data )
 553         ((lsmash_entry_data_eliminator)eliminator)( entry->data );
 554     if( entry == list->last_accessed_entry )
 555     {
 556         if( next )
 557             list->last_accessed_entry = next;
 558         else if( prev )
 559         {
 560             list->last_accessed_entry = prev;
 561             list->last_accessed_number -= 1;
 562         }
 563         else
 564         {
 565             list->last_accessed_entry = NULL;
 566             list->last_accessed_number = 0;
 567         }
 568     }
 569     else
 570     {
 571         /* We can't know the current entry number immediately,
 572          * so discard the last accessed entry info because time is wasted to know it. */
 573         list->last_accessed_entry = NULL;
 574         list->last_accessed_number = 0;
 575     }
 576     free( entry );
 577     list->entry_count -= 1;
 578     return 0;
 579 }
 580
 581 int lsmash_remove_entry( lsmash_entry_list_t *list, uint32_t entry_number, void* eliminator )
 582 {
 583     lsmash_entry_t *entry = lsmash_get_entry( list, entry_number );
 584     return lsmash_remove_entry_direct( list, entry, eliminator );
 585 }
 586
 587 void lsmash_remove_entries( lsmash_entry_list_t *list, void* eliminator )
 588 {
 589     if( !list )
 590         return;
 591     if( !eliminator )
 592         eliminator = free;
 593     for( lsmash_entry_t *entry = list->head; entry; )
 594     {
 595         lsmash_entry_t *next = entry->next;
 596         if( entry->data )
 597             ((lsmash_entry_data_eliminator)eliminator)( entry->data );
 598         free( entry );
 599         entry = next;
 600     }
 601     lsmash_init_entry_list( list );
 602 }
 603
 604 void lsmash_remove_list( lsmash_entry_list_t *list, void* eliminator )
 605 {
 606     if( !list )
 607         return;
 608     lsmash_remove_entries( list, eliminator );
 609     free( list );
 610 }
 611
 612 lsmash_entry_t *lsmash_get_entry( lsmash_entry_list_t *list, uint32_t entry_number )
 613 {
 614     if( !list || !entry_number || entry_number > list->entry_count )
 615         return NULL;
 616     int shortcut = 1;
 617     lsmash_entry_t *entry = NULL;
 618     if( list->last_accessed_entry )
 619     {
 620         if( entry_number == list->last_accessed_number )
 621             entry = list->last_accessed_entry;
 622         else if( entry_number == list->last_accessed_number + 1 )
 623             entry = list->last_accessed_entry->next;
 624         else if( entry_number == list->last_accessed_number - 1 )
 625             entry = list->last_accessed_entry->prev;
 626         else
 627             shortcut = 0;
 628     }
 629     else
 630         shortcut = 0;
 631     if( !shortcut )
 632     {
 633         if( entry_number <= (list->entry_count >> 1) )
 634         {
 635             /* Look for from the head. */
 636             uint32_t distance_plus_one = entry_number;
 637             for( entry = list->head; entry && --distance_plus_one; entry = entry->next );
 638         }
 639         else
 640         {
 641             /* Look for from the tail. */
 642             uint32_t distance = list->entry_count - entry_number;
 643             for( entry = list->tail; entry && distance--; entry = entry->prev );
 644         }
 645     }
 646     if( entry )
 647     {
 648         list->last_accessed_entry = entry;
 649         list->last_accessed_number = entry_number;
 650     }
 651     return entry;
 652 }
 653
 654 void *lsmash_get_entry_data( lsmash_entry_list_t *list, uint32_t entry_number )
 655 {
 656     lsmash_entry_t *entry = lsmash_get_entry( list, entry_number );
 657     return entry ? entry->data : NULL;
 658 }
 659 /*---- ----*/
 660
 661 /*---- type ----*/
 662 double lsmash_fixed2double( uint64_t value, int frac_width )
 663 {
 664     return value / (double)(1ULL << frac_width);
 665 }
 666
 667 float lsmash_int2float32( uint32_t value )
 668 {
 669     return (union {uint32_t i; float f;}){value}.f;
 670 }
 671
 672 double lsmash_int2float64( uint64_t value )
 673 {
 674     return (union {uint64_t i; double d;}){value}.d;
 675 }
 676 /*---- ----*/
 677
 678 /*---- allocator ----*/
 679 void *lsmash_malloc_zero( size_t size )
 680 {
 681     if( !size )
 682         return NULL;
 683     void *p = malloc( size );
 684     if( !p )
 685         return NULL;
 686     memset( p, 0, size );
 687     return p;
 688 }
 689
 690 void *lsmash_memdup( void *src, size_t size )
 691 {
 692     if( !size )
 693         return NULL;
 694     void *dst = malloc( size );
 695     if( !dst )
 696         return NULL;
 697     memcpy( dst, src, size );
 698     return dst;
 699 }
 700
 701 lsmash_multiple_buffers_t *lsmash_create_multiple_buffers( uint32_t number_of_buffers, uint32_t buffer_size )
 702 {
 703     if( (uint64_t)number_of_buffers * buffer_size > UINT32_MAX )
 704         return NULL;
 705     lsmash_multiple_buffers_t *multiple_buffer = malloc( sizeof(lsmash_multiple_buffers_t) );
 706     if( !multiple_buffer )
 707         return NULL;
 708     multiple_buffer->buffers = malloc( number_of_buffers * buffer_size );
 709     if( !multiple_buffer->buffers )
 710     {
 711         free( multiple_buffer );
 712         return NULL;
 713     }
 714     multiple_buffer->number_of_buffers = number_of_buffers;
 715     multiple_buffer->buffer_size = buffer_size;
 716     return multiple_buffer;
 717 }
 718
 719 void *lsmash_withdraw_buffer( lsmash_multiple_buffers_t *multiple_buffer, uint32_t buffer_number )
 720 {
 721     if( !multiple_buffer || !buffer_number || buffer_number > multiple_buffer->number_of_buffers )
 722         return NULL;
 723     return multiple_buffer->buffers + (buffer_number - 1) * multiple_buffer->buffer_size;
 724 }
 725
 726 lsmash_multiple_buffers_t *lsmash_resize_multiple_buffers( lsmash_multiple_buffers_t *multiple_buffer, uint32_t buffer_size )
 727 {
 728     if( !multiple_buffer )
 729         return NULL;
 730     if( buffer_size == multiple_buffer->buffer_size )
 731         return multiple_buffer;
 732     if( (uint64_t)multiple_buffer->number_of_buffers * buffer_size > UINT32_MAX )
 733         return NULL;
 734     void *temp;
 735     if( buffer_size > multiple_buffer->buffer_size )
 736     {
 737         temp = realloc( multiple_buffer->buffers, multiple_buffer->number_of_buffers * buffer_size );
 738         if( !temp )
 739             return NULL;
 740         for( uint32_t i = multiple_buffer->number_of_buffers - 1; i ; i-- )
 741             memmove( temp + buffer_size, temp + i * multiple_buffer->buffer_size, multiple_buffer->buffer_size );
 742     }
 743     else
 744     {
 745         for( uint32_t i = 1; i < multiple_buffer->number_of_buffers; i++ )
 746             memmove( multiple_buffer->buffers + buffer_size, multiple_buffer->buffers + i * multiple_buffer->buffer_size, multiple_buffer->buffer_size );
 747         temp = realloc( multiple_buffer->buffers, multiple_buffer->number_of_buffers * buffer_size );
 748         if( !temp )
 749             return NULL;
 750     }
 751     multiple_buffer->buffers = temp;
 752     multiple_buffer->buffer_size = buffer_size;
 753     return multiple_buffer;
 754 }
 755
 756 void lsmash_destroy_multiple_buffers( lsmash_multiple_buffers_t *multiple_buffer )
 757 {
 758     if( !multiple_buffer )
 759         return;
 760     if( multiple_buffer->buffers )
 761         free( multiple_buffer->buffers );
 762     free( multiple_buffer );
 763 }
 764 /*---- ----*/
 765
 766 /*---- others ----*/
 767 void lsmash_log( lsmash_log_level level, const char* message, ... )
 768 {
 769     char *prefix;
 770     va_list args;
 771
 772     va_start( args, message );
 773     switch( level )
 774     {
 775         case LSMASH_LOG_ERROR:
 776             prefix = "Error";
 777             break;
 778         case LSMASH_LOG_WARNING:
 779             prefix = "Warning";
 780             break;
 781         case LSMASH_LOG_INFO:
 782             prefix = "Info";
 783             break;
 784         default:
 785             prefix = "Unknown";
 786             break;
 787     }
 788
 789     fprintf( stderr, "[%s]: ", prefix );
 790     vfprintf( stderr, message, args );
 791     va_end( args );
 792 }
 793
 794 uint32_t lsmash_count_bits( uint32_t bits )
 795 {
 796     bits = (bits & 0x55555555) + ((bits >>  1) & 0x55555555);
 797     bits = (bits & 0x33333333) + ((bits >>  2) & 0x33333333);
 798     bits = (bits & 0x0f0f0f0f) + ((bits >>  4) & 0x0f0f0f0f);
 799     bits = (bits & 0x00ff00ff) + ((bits >>  8) & 0x00ff00ff);
 800     return (bits & 0x0000ffff) + ((bits >> 16) & 0x0000ffff);
 801 }
 802
 803 /* for qsort function */
 804 int lsmash_compare_dts( const lsmash_media_ts_t *a, const lsmash_media_ts_t *b )
 805 {
 806     int64_t diff = (int64_t)(a->dts - b->dts);
 807     return diff > 0 ? 1 : (diff == 0 ? 0 : -1);
 808 }
 809
 810 int lsmash_compare_cts( const lsmash_media_ts_t *a, const lsmash_media_ts_t *b )
 811 {
 812     int64_t diff = (int64_t)(a->cts - b->cts);
 813     return diff > 0 ? 1 : (diff == 0 ? 0 : -1);
 814 }