common/bytes.c

   1 /*****************************************************************************
   2  * bytes.c
   3  *****************************************************************************
   4  * Copyright (C) 2010-2014 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 <string.h>
  26 #include <limits.h>
  27
  28 lsmash_bs_t *lsmash_bs_create( void )
  29 {
  30     lsmash_bs_t *bs = lsmash_malloc_zero( sizeof(lsmash_bs_t) );
  31     if( !bs )
  32         return NULL;
  33     bs->unseekable      = 1;
  34     bs->buffer.internal = 1;
  35     bs->buffer.max_size = BS_MAX_DEFAULT_READ_SIZE;
  36     return bs;
  37 }
  38
  39 static void bs_buffer_free( lsmash_bs_t *bs )
  40 {
  41     if( bs->buffer.internal )
  42         lsmash_free( bs->buffer.data );
  43     bs->buffer.data  = NULL;
  44     bs->buffer.alloc = 0;
  45     bs->buffer.store = 0;
  46     bs->buffer.pos   = 0;
  47 }
  48
  49 void lsmash_bs_cleanup( lsmash_bs_t *bs )
  50 {
  51     if( !bs )
  52         return;
  53     bs_buffer_free( bs );
  54     lsmash_free( bs );
  55 }
  56
  57 int lsmash_bs_set_empty_stream( lsmash_bs_t *bs, uint8_t *data, size_t size )
  58 {
  59     if( !bs )
  60         return LSMASH_ERR_FUNCTION_PARAM;
  61     bs->stream     = NULL;      /* empty stream */
  62     bs->eof        = 1;         /* unreadable because of empty stream */
  63     bs->eob        = 0;         /* readable on the buffer */
  64     bs->error      = 0;
  65     bs->unseekable = 1;         /* only seek on the buffer */
  66     bs->written    = size;      /* behave as if the size of the empty stream is 'size' */
  67     bs->offset     = size;      /* behave as if the poiter of the stream is at the end */
  68     bs->buffer.unseekable = 0;  /* only seek on the buffer */
  69     bs->buffer.internal   = 0;  /* must not be allocated internally */
  70     bs->buffer.data       = data;
  71     bs->buffer.store      = size;
  72     bs->buffer.alloc      = size;
  73     bs->buffer.pos        = 0;
  74     bs->buffer.max_size   = 0;  /* make no sense */
  75     bs->buffer.count      = 0;
  76     bs->read  = NULL;
  77     bs->write = NULL;
  78     bs->seek  = NULL;
  79     return 0;
  80 }
  81
  82 void lsmash_bs_empty( lsmash_bs_t *bs )
  83 {
  84     if( !bs )
  85         return;
  86     if( bs->buffer.data )
  87         memset( bs->buffer.data, 0, bs->buffer.alloc );
  88     bs->buffer.store = 0;
  89     bs->buffer.pos   = 0;
  90 }
  91
  92 static void bs_alloc( lsmash_bs_t *bs, size_t alloc )
  93 {
  94     if( (bs->buffer.alloc >= alloc) || bs->error )
  95         return;
  96     if( !bs->buffer.internal )
  97     {
  98         /* We cannot re-allocate the memory block. */
  99         bs->error = 1;
 100         return;
 101     }
 102     alloc += (1 << 16);
 103     alloc  = LSMASH_MAX( alloc, bs->buffer.max_size );
 104     uint8_t *data;
 105     if( !bs->buffer.data )
 106         data = lsmash_malloc( alloc );
 107     else
 108         data = lsmash_realloc( bs->buffer.data, alloc );
 109     if( !data )
 110     {
 111         bs_buffer_free( bs );
 112         bs->error = 1;
 113         return;
 114     }
 115     bs->buffer.internal = 1;
 116     bs->buffer.data     = data;
 117     bs->buffer.alloc    = alloc;
 118 }
 119
 120 static uint64_t bs_estimate_seek_offset( lsmash_bs_t *bs, int64_t offset, int whence )
 121 {
 122     /* Calculate the offset after the seek. */
 123     uint64_t dst_offset;
 124     if( whence == SEEK_SET )
 125     {
 126         assert( offset >= 0 );
 127         if( bs->written < offset )
 128             dst_offset = bs->written;
 129         else
 130             dst_offset = offset;
 131     }
 132     else if( whence == SEEK_CUR )
 133     {
 134         if( offset < 0 && bs->offset < -offset )
 135             dst_offset = 0;
 136         else if( offset > 0 && bs->written < bs->offset + offset )
 137             dst_offset = bs->written;
 138         else
 139             dst_offset = bs->offset + offset;
 140     }
 141     else /* if( whence == SEEK_END ) */
 142     {
 143         assert( offset <= 0 );
 144         if( bs->written < -offset )
 145             dst_offset = 0;
 146         else
 147             dst_offset = bs->written + offset;
 148     }
 149     return dst_offset;
 150 }
 151
 152 /* TODO: Support offset > INT64_MAX */
 153 int64_t lsmash_bs_write_seek( lsmash_bs_t *bs, int64_t offset, int whence )
 154 {
 155     if( bs->unseekable )
 156         return LSMASH_ERR_NAMELESS;
 157     if( whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END )
 158         return LSMASH_ERR_FUNCTION_PARAM;
 159     /* Try to seek the stream. */
 160     int64_t ret = bs->seek( bs->stream, offset, whence );
 161     if( ret < 0 )
 162         return ret;
 163     bs->offset = bs_estimate_seek_offset( bs, offset, whence );
 164     bs->eof    = 0;
 165     bs->eob    = 0;
 166     return ret;
 167 }
 168
 169 /* TODO: Support offset > INT64_MAX */
 170 int64_t lsmash_bs_read_seek( lsmash_bs_t *bs, int64_t offset, int whence )
 171 {
 172     if( whence != SEEK_SET && whence != SEEK_CUR && whence != SEEK_END )
 173         return LSMASH_ERR_FUNCTION_PARAM;
 174     if( whence == SEEK_CUR )
 175         offset -= lsmash_bs_get_remaining_buffer_size( bs );
 176     /* Check whether we can seek on the buffer. */
 177     if( !bs->buffer.unseekable )
 178     {
 179         assert( bs->offset >= bs->buffer.store );
 180         uint64_t dst_offset = bs_estimate_seek_offset( bs, offset, whence );
 181         uint64_t offset_s = bs->offset - bs->buffer.store;
 182         uint64_t offset_e = bs->offset;
 183         if( bs->unseekable || (dst_offset >= offset_s && dst_offset < offset_e) )
 184         {
 185             /* OK, we can. So, seek on the buffer. */
 186             bs->buffer.pos = dst_offset - offset_s;
 187             bs->eob        = 0;
 188             return lsmash_bs_get_stream_pos( bs );
 189         }
 190     }
 191     if( bs->unseekable )
 192         return LSMASH_ERR_NAMELESS;
 193     /* Try to seek the stream. */
 194     int64_t ret = bs->seek( bs->stream, offset, whence );
 195     if( ret < 0 )
 196         return ret;
 197     bs->offset  = ret;
 198     bs->written = LSMASH_MAX( bs->written, bs->offset );
 199     bs->eof     = 0;
 200     bs->eob     = 0;
 201     /* The data on the buffer is invalid. */
 202     lsmash_bs_empty( bs );
 203     return ret;
 204 }
 205
 206 static void bs_dispose_past_data( lsmash_bs_t *bs )
 207 {
 208     /* Move remainder bytes. */
 209     assert( bs->buffer.store >= bs->buffer.pos );
 210     size_t remainder = lsmash_bs_get_remaining_buffer_size( bs );
 211     if( bs->buffer.pos && remainder )
 212         memmove( lsmash_bs_get_buffer_data_start( bs ), lsmash_bs_get_buffer_data( bs ), remainder );
 213     bs->buffer.store = remainder;
 214     bs->buffer.pos   = 0;
 215 }
 216
 217 /*---- bitstream writer ----*/
 218 void lsmash_bs_put_byte( lsmash_bs_t *bs, uint8_t value )
 219 {
 220     if( bs->buffer.internal
 221      || bs->buffer.data )
 222     {
 223         bs_alloc( bs, bs->buffer.store + 1 );
 224         if( bs->error )
 225             return;
 226         bs->buffer.data[ bs->buffer.store ] = value;
 227     }
 228     ++ bs->buffer.store;
 229 }
 230
 231 void lsmash_bs_put_bytes( lsmash_bs_t *bs, uint32_t size, void *value )
 232 {
 233     if( size == 0 || !value )
 234         return;
 235     if( bs->buffer.internal
 236      || bs->buffer.data )
 237     {
 238         bs_alloc( bs, bs->buffer.store + size );
 239         if( bs->error )
 240             return;
 241         memcpy( lsmash_bs_get_buffer_data_end( bs ), value, size );
 242     }
 243     bs->buffer.store += size;
 244 }
 245
 246 void lsmash_bs_put_be16( lsmash_bs_t *bs, uint16_t value )
 247 {
 248     lsmash_bs_put_byte( bs, value >> 8 );
 249     lsmash_bs_put_byte( bs, value );
 250 }
 251
 252 void lsmash_bs_put_be24( lsmash_bs_t *bs, uint32_t value )
 253 {
 254     lsmash_bs_put_byte( bs, value >> 16 );
 255     lsmash_bs_put_be16( bs, value );
 256 }
 257
 258 void lsmash_bs_put_be32( lsmash_bs_t *bs, uint32_t value )
 259 {
 260     lsmash_bs_put_be16( bs, value >> 16 );
 261     lsmash_bs_put_be16( bs, value );
 262 }
 263
 264 void lsmash_bs_put_be64( lsmash_bs_t *bs, uint64_t value )
 265 {
 266     lsmash_bs_put_be32( bs, value >> 32 );
 267     lsmash_bs_put_be32( bs, value );
 268 }
 269
 270 void lsmash_bs_put_byte_from_64( lsmash_bs_t *bs, uint64_t value )
 271 {
 272     lsmash_bs_put_byte( bs, value );
 273 }
 274
 275 void lsmash_bs_put_be16_from_64( lsmash_bs_t *bs, uint64_t value )
 276 {
 277     lsmash_bs_put_be16( bs, value );
 278 }
 279
 280 void lsmash_bs_put_be24_from_64( lsmash_bs_t *bs, uint64_t value )
 281 {
 282     lsmash_bs_put_be24( bs, value );
 283 }
 284
 285 void lsmash_bs_put_be32_from_64( lsmash_bs_t *bs, uint64_t value )
 286 {
 287     lsmash_bs_put_be32( bs, value );
 288 }
 289
 290 void lsmash_bs_put_le16( lsmash_bs_t *bs, uint16_t value )
 291 {
 292     lsmash_bs_put_byte( bs, value );
 293     lsmash_bs_put_byte( bs, value >> 8 );
 294 }
 295
 296 void lsmash_bs_put_le32( lsmash_bs_t *bs, uint32_t value )
 297 {
 298     lsmash_bs_put_le16( bs, value );
 299     lsmash_bs_put_le16( bs, value >> 16 );
 300 }
 301
 302 int lsmash_bs_flush_buffer( lsmash_bs_t *bs )
 303 {
 304     if( !bs )
 305         return LSMASH_ERR_FUNCTION_PARAM;
 306     if( bs->buffer.store == 0
 307      || (bs->stream && bs->write && !bs->buffer.data) )
 308         return 0;
 309     if( bs->error
 310      || (bs->stream && bs->write && bs->write( bs->stream, lsmash_bs_get_buffer_data_start( bs ), bs->buffer.store ) != bs->buffer.store) )
 311     {
 312         bs_buffer_free( bs );
 313         bs->error = 1;
 314         return LSMASH_ERR_NAMELESS;
 315     }
 316     if( bs->write )
 317     {
 318         bs->written += bs->buffer.store;
 319         bs->offset  += bs->buffer.store;
 320     }
 321     bs->buffer.store = 0;
 322     return 0;
 323 }
 324
 325 int lsmash_bs_write_data( lsmash_bs_t *bs, uint8_t *buf, size_t size )
 326 {
 327     if( !bs || size > INT_MAX )
 328         return LSMASH_ERR_FUNCTION_PARAM;
 329     if( !buf || size == 0 )
 330         return 0;
 331     if( bs->error || !bs->stream )
 332     {
 333         bs_buffer_free( bs );
 334         bs->error = 1;
 335         return LSMASH_ERR_NAMELESS;
 336     }
 337     int write_size = bs->write( bs->stream, buf, size );
 338     bs->written += write_size;
 339     bs->offset  += write_size;
 340     return write_size != size ? LSMASH_ERR_NAMELESS : 0;
 341 }
 342
 343 void *lsmash_bs_export_data( lsmash_bs_t *bs, uint32_t *length )
 344 {
 345     if( !bs || !bs->buffer.data || bs->buffer.store == 0 || bs->error )
 346         return NULL;
 347     void *buf = lsmash_memdup( lsmash_bs_get_buffer_data_start( bs ), bs->buffer.store );
 348     if( !buf )
 349         return NULL;
 350     if( length )
 351         *length = bs->buffer.store;
 352     return buf;
 353 }
 354 /*---- ----*/
 355
 356 /*---- bitstream reader ----*/
 357 static void bs_fill_buffer( lsmash_bs_t *bs )
 358 {
 359     if( bs->eof || bs->error )
 360         return;
 361     if( !bs->read || !bs->stream || bs->buffer.max_size == 0 )
 362     {
 363         bs->eof = 1;
 364         return;
 365     }
 366     if( !bs->buffer.data )
 367     {
 368         bs_alloc( bs, bs->buffer.max_size );
 369         if( bs->error )
 370             return;
 371     }
 372     /* Read bytes from the stream to fill the buffer. */
 373     bs_dispose_past_data( bs );
 374     while( bs->buffer.alloc > bs->buffer.store )
 375     {
 376         uint64_t invalid_buffer_size = bs->buffer.alloc - bs->buffer.store;
 377         int max_read_size = LSMASH_MIN( invalid_buffer_size, bs->buffer.max_size );
 378         int read_size = bs->read( bs->stream, lsmash_bs_get_buffer_data_end( bs ), max_read_size );
 379         if( read_size == 0 )
 380         {
 381             bs->eof = 1;
 382             return;
 383         }
 384         else if( read_size < 0 )
 385         {
 386             bs->error = 1;
 387             return;
 388         }
 389         bs->buffer.unseekable = 0;
 390         bs->buffer.store += read_size;
 391         bs->offset       += read_size;
 392         bs->written = LSMASH_MAX( bs->written, bs->offset );
 393     }
 394 }
 395
 396 uint8_t lsmash_bs_show_byte( lsmash_bs_t *bs, uint32_t offset )
 397 {
 398     if( bs->error )
 399         return 0;
 400     if( offset >= lsmash_bs_get_remaining_buffer_size( bs ) )
 401     {
 402         bs_fill_buffer( bs );
 403         if( bs->error )
 404             return 0;
 405         if( offset >= lsmash_bs_get_remaining_buffer_size( bs ) )
 406         {
 407             if( bs->eof )
 408                 /* No more read from both the stream and the buffer. */
 409                 return 0;
 410             /* We need increase the buffer size. */
 411             bs_alloc( bs, bs->buffer.pos + offset + 1 );
 412             bs_fill_buffer( bs );
 413             if( bs->error )
 414                 return 0;
 415         }
 416     }
 417     return bs->buffer.data[ bs->buffer.pos + offset ];
 418 }
 419
 420 uint16_t lsmash_bs_show_be16( lsmash_bs_t *bs, uint32_t offset )
 421 {
 422     return ((uint16_t)lsmash_bs_show_byte( bs, offset     ) << 8)
 423          | ((uint16_t)lsmash_bs_show_byte( bs, offset + 1 ));
 424 }
 425
 426 uint32_t lsmash_bs_show_be24( lsmash_bs_t *bs, uint32_t offset )
 427 {
 428     return ((uint32_t)lsmash_bs_show_byte( bs, offset     ) << 16)
 429          | ((uint32_t)lsmash_bs_show_byte( bs, offset + 1 ) <<  8)
 430          | ((uint32_t)lsmash_bs_show_byte( bs, offset + 2 ));
 431 }
 432
 433 uint32_t lsmash_bs_show_be32( lsmash_bs_t *bs, uint32_t offset )
 434 {
 435     return ((uint32_t)lsmash_bs_show_byte( bs, offset     ) << 24)
 436          | ((uint32_t)lsmash_bs_show_byte( bs, offset + 1 ) << 16)
 437          | ((uint32_t)lsmash_bs_show_byte( bs, offset + 2 ) <<  8)
 438          | ((uint32_t)lsmash_bs_show_byte( bs, offset + 3 ));
 439 }
 440
 441 uint64_t lsmash_bs_show_be64( lsmash_bs_t *bs, uint32_t offset )
 442 {
 443     return ((uint64_t)lsmash_bs_show_byte( bs, offset     ) << 56)
 444          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 1 ) << 48)
 445          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 2 ) << 40)
 446          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 3 ) << 32)
 447          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 4 ) << 24)
 448          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 5 ) << 16)
 449          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 6 ) <<  8)
 450          | ((uint64_t)lsmash_bs_show_byte( bs, offset + 7 ));
 451 }
 452
 453 uint8_t lsmash_bs_get_byte( lsmash_bs_t *bs )
 454 {
 455     if( bs->eob || bs->error )
 456         return 0;
 457     assert( bs->buffer.pos <= bs->buffer.store );
 458     if( bs->buffer.pos == bs->buffer.store )
 459     {
 460         bs_fill_buffer( bs );
 461         if( bs->error )
 462             return 0;
 463         if( bs->buffer.pos == bs->buffer.store && bs->eof )
 464         {
 465             /* No more read from both the stream and the buffer. */
 466             bs->eob = 1;
 467             return 0;
 468         }
 469     }
 470     ++ bs->buffer.count;    /* increment counter */
 471     return bs->buffer.data[ bs->buffer.pos ++ ];
 472 }
 473
 474 void lsmash_bs_skip_bytes( lsmash_bs_t *bs, uint32_t size )
 475 {
 476     if( bs->eob || bs->error || size == 0 )
 477         return;
 478     uint64_t remainder;
 479     uint64_t offset = 0;
 480     while( size > lsmash_bs_get_remaining_buffer_size( bs ) )
 481     {
 482         remainder = lsmash_bs_get_remaining_buffer_size( bs );
 483         offset += remainder;
 484         size   -= remainder;
 485         bs->buffer.pos = bs->buffer.store;
 486         if( bs->eof )
 487         {
 488             /* No more read from both the stream and the buffer. */
 489             bs->eob = 1;
 490             break;
 491         }
 492         else
 493         {
 494             bs_fill_buffer( bs );
 495             if( bs->error )
 496                 break;
 497         }
 498     }
 499     remainder = LSMASH_MIN( size, lsmash_bs_get_remaining_buffer_size( bs ) );
 500     offset           += remainder;
 501     bs->buffer.pos   += remainder;
 502     bs->buffer.count += offset;
 503 }
 504
 505 void lsmash_bs_skip_bytes_64( lsmash_bs_t *bs, uint64_t size )
 506 {
 507     while( size )
 508     {
 509         uint64_t skip_bytes = LSMASH_MIN( size, UINT32_MAX );
 510         lsmash_bs_skip_bytes( bs, (uint32_t)skip_bytes );
 511         size -= skip_bytes;
 512         if( bs->eob )
 513             return;
 514     }
 515 }
 516
 517 static int64_t bs_get_bytes( lsmash_bs_t *bs, uint32_t size, uint8_t *buf )
 518 {
 519     size_t    remainder;
 520     size_t    remain_size = size;
 521     uintptr_t offset      = 0;
 522     while( remain_size > lsmash_bs_get_remaining_buffer_size( bs ) )
 523     {
 524         remainder = lsmash_bs_get_remaining_buffer_size( bs );
 525         memcpy( buf + offset, lsmash_bs_get_buffer_data( bs ), remainder );
 526         offset      += remainder;
 527         remain_size -= remainder;
 528         bs->buffer.pos = bs->buffer.store;
 529         if( bs->eof )
 530         {
 531             /* No more read from both the stream and the buffer. */
 532             bs->eob = 1;
 533             break;
 534         }
 535         else
 536         {
 537             bs_fill_buffer( bs );
 538             if( bs->error )
 539             {
 540                 bs->buffer.count += offset;
 541                 return LSMASH_ERR_NAMELESS;
 542             }
 543         }
 544     }
 545     remainder = LSMASH_MIN( remain_size, lsmash_bs_get_remaining_buffer_size( bs ) );
 546     memcpy( buf + offset, lsmash_bs_get_buffer_data( bs ), remainder );
 547     offset           += remainder;
 548     bs->buffer.pos   += remainder;
 549     bs->buffer.count += offset;
 550     if( offset < size )
 551         memset( buf + offset, 0, size - offset );
 552     return (int64_t)offset;
 553 }
 554
 555 uint8_t *lsmash_bs_get_bytes( lsmash_bs_t *bs, uint32_t size )
 556 {
 557     if( bs->eob || bs->error || size == 0 )
 558         return NULL;
 559     uint8_t *value = lsmash_malloc( size );
 560     if( !value )
 561     {
 562         bs->error = 1;
 563         return NULL;
 564     }
 565     if( bs_get_bytes( bs, size, value ) < 0 )
 566     {
 567         lsmash_free( value );
 568         return NULL;
 569     }
 570     return value;
 571 }
 572
 573 int64_t lsmash_bs_get_bytes_ex( lsmash_bs_t *bs, uint32_t size, uint8_t *value )
 574 {
 575     if( size == 0 )
 576         return 0;
 577     if( bs->eob || bs->error )
 578         return LSMASH_ERR_NAMELESS;
 579     return bs_get_bytes( bs, size, value );
 580 }
 581
 582 uint16_t lsmash_bs_get_be16( lsmash_bs_t *bs )
 583 {
 584     uint16_t    value = lsmash_bs_get_byte( bs );
 585     return (value<<8) | lsmash_bs_get_byte( bs );
 586 }
 587
 588 uint32_t lsmash_bs_get_be24( lsmash_bs_t *bs )
 589 {
 590     uint32_t     value = lsmash_bs_get_byte( bs );
 591     return (value<<16) | lsmash_bs_get_be16( bs );
 592 }
 593
 594 uint32_t lsmash_bs_get_be32( lsmash_bs_t *bs )
 595 {
 596     uint32_t     value = lsmash_bs_get_be16( bs );
 597     return (value<<16) | lsmash_bs_get_be16( bs );
 598 }
 599
 600 uint64_t lsmash_bs_get_be64( lsmash_bs_t *bs )
 601 {
 602     uint64_t     value = lsmash_bs_get_be32( bs );
 603     return (value<<32) | lsmash_bs_get_be32( bs );
 604 }
 605
 606 uint64_t lsmash_bs_get_byte_to_64( lsmash_bs_t *bs )
 607 {
 608     return lsmash_bs_get_byte( bs );
 609 }
 610
 611 uint64_t lsmash_bs_get_be16_to_64( lsmash_bs_t *bs )
 612 {
 613     return lsmash_bs_get_be16( bs );
 614 }
 615
 616 uint64_t lsmash_bs_get_be24_to_64( lsmash_bs_t *bs )
 617 {
 618     return lsmash_bs_get_be24( bs );
 619 }
 620
 621 uint64_t lsmash_bs_get_be32_to_64( lsmash_bs_t *bs )
 622 {
 623     return lsmash_bs_get_be32( bs );
 624 }
 625
 626 uint16_t lsmash_bs_get_le16( lsmash_bs_t *bs )
 627 {
 628     uint16_t value = lsmash_bs_get_byte( bs );
 629     return value | (lsmash_bs_get_byte( bs ) << 8);
 630 }
 631
 632 uint32_t lsmash_bs_get_le32( lsmash_bs_t *bs )
 633 {
 634     uint32_t value = lsmash_bs_get_le16( bs );
 635     return value | (lsmash_bs_get_le16( bs ) << 16);
 636 }
 637
 638 int lsmash_bs_read( lsmash_bs_t *bs, uint32_t size )
 639 {
 640     if( !bs || size > INT_MAX )
 641         return LSMASH_ERR_FUNCTION_PARAM;
 642     if( size == 0 )
 643         return 0;
 644     bs_alloc( bs, bs->buffer.store + size );
 645     if( bs->error || !bs->stream )
 646     {
 647         bs->error = 1;
 648         return LSMASH_ERR_NAMELESS;
 649     }
 650     int read_size = bs->read( bs->stream, lsmash_bs_get_buffer_data_end( bs ), size );
 651     if( read_size == 0 )
 652     {
 653         bs->eof = 1;
 654         return 0;
 655     }
 656     else if( read_size < 0 )
 657     {
 658         bs->error = 1;
 659         return LSMASH_ERR_NAMELESS;
 660     }
 661     bs->buffer.store += read_size;
 662     bs->offset       += read_size;
 663     bs->written = LSMASH_MAX( bs->written, bs->offset );
 664     return read_size;
 665 }
 666
 667 int lsmash_bs_read_data( lsmash_bs_t *bs, uint8_t *buf, size_t *size )
 668 {
 669     if( !bs || !size || *size > INT_MAX )
 670         return LSMASH_ERR_FUNCTION_PARAM;
 671     if( !buf || *size == 0 )
 672         return 0;
 673     if( bs->error || !bs->stream )
 674     {
 675         bs->error = 1;
 676         return LSMASH_ERR_NAMELESS;
 677     }
 678     int read_size = bs->read( bs->stream, buf, *size );
 679     if( read_size == 0 )
 680         bs->eof = 1;
 681     else if( read_size < 0 )
 682     {
 683         bs->error = 1;
 684         return LSMASH_ERR_NAMELESS;
 685     }
 686     bs->buffer.unseekable = 1;
 687     bs->offset += read_size;
 688     *size       = read_size;
 689     bs->written = LSMASH_MAX( bs->written, bs->offset );
 690     return 0;
 691 }
 692
 693 int lsmash_bs_import_data( lsmash_bs_t *bs, void *data, uint32_t length )
 694 {
 695     if( !bs || !data || length == 0 )
 696         return LSMASH_ERR_FUNCTION_PARAM;
 697     if( bs->error )
 698         return LSMASH_ERR_NAMELESS;
 699     bs_alloc( bs, bs->buffer.store + length );
 700     if( bs->error || !bs->buffer.data ) /* means, failed to alloc. */
 701     {
 702         bs_buffer_free( bs );
 703         return LSMASH_ERR_NAMELESS;
 704     }
 705     memcpy( lsmash_bs_get_buffer_data_end( bs ), data, length );
 706     bs->buffer.store += length;
 707     return 0;
 708 }
 709 /*---- ----*/
 710
 711 /*---- basic I/O ----*/
 712 int lsmash_fread_wrapper( void *opaque, uint8_t *buf, int size )
 713 {
 714     int read_size = fread( buf, 1, size, (FILE *)opaque );
 715     return ferror( (FILE *)opaque ) ? LSMASH_ERR_NAMELESS : read_size;
 716 }
 717
 718 int lsmash_fwrite_wrapper( void *opaque, uint8_t *buf, int size )
 719 {
 720     return fwrite( buf, 1, size, (FILE *)opaque );
 721 }
 722
 723 int64_t lsmash_fseek_wrapper( void *opaque, int64_t offset, int whence )
 724 {
 725     if( lsmash_fseek( (FILE *)opaque, offset, whence ) != 0 )
 726         return LSMASH_ERR_NAMELESS;
 727     return lsmash_ftell( (FILE *)opaque );
 728 }