include/vlc_block_helper.h

   1 /*****************************************************************************
   2  * vlc_block_helper.h: Helper functions for data blocks management.
   3  *****************************************************************************
   4  * Copyright (C) 2003 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 #ifndef VLC_BLOCK_HELPER_H
  25 #define VLC_BLOCK_HELPER_H 1
  26
  27 #include <vlc_block.h>
  28
  29 typedef struct block_bytestream_t
  30 {
  31     block_t *p_chain;  /**< byte stream head block */
  32     block_t *p_block;  /**< byte stream read pointer block */
  33     size_t   i_offset; /**< byte stream read pointer offset within block */
  34     /* TODO? add tail pointer for faster push? */
  35 } block_bytestream_t;
  36
  37 /*****************************************************************************
  38  * block_bytestream_t management
  39  *****************************************************************************/
  40 static inline void block_BytestreamInit( block_bytestream_t *p_bytestream )
  41 {
  42     p_bytestream->p_chain = p_bytestream->p_block = NULL;
  43     p_bytestream->i_offset = 0;
  44 }
  45
  46 static inline void block_BytestreamRelease( block_bytestream_t *p_bytestream )
  47 {
  48     for( block_t *block = p_bytestream->p_chain; block != NULL; )
  49     {
  50         block_t *p_next = block->p_next;
  51
  52         block_Release( block );
  53         block = p_next;
  54     }
  55 }
  56
  57 /**
  58  * It flush all data (read and unread) from a block_bytestream_t.
  59  */
  60 static inline void block_BytestreamEmpty( block_bytestream_t *p_bytestream )
  61 {
  62     block_BytestreamRelease( p_bytestream );
  63     block_BytestreamInit( p_bytestream );
  64 }
  65
  66 /**
  67  * It flushes all already read data from a block_bytestream_t.
  68  */
  69 static inline void block_BytestreamFlush( block_bytestream_t *p_bytestream )
  70 {
  71     block_t *block = p_bytestream->p_chain;
  72
  73     while( block != p_bytestream->p_block )
  74     {
  75         block_t *p_next = block->p_next;
  76
  77         block_Release( block );
  78         block = p_next;
  79     }
  80
  81     while( block != NULL && block->i_buffer == p_bytestream->i_offset )
  82     {
  83         block_t *p_next = block->p_next;
  84
  85         block_Release( block );
  86         block = p_next;
  87         p_bytestream->i_offset = 0;
  88     }
  89
  90     p_bytestream->p_chain = p_bytestream->p_block = block;
  91 }
  92
  93 static inline void block_BytestreamPush( block_bytestream_t *p_bytestream,
  94                                          block_t *p_block )
  95 {
  96     block_ChainAppend( &p_bytestream->p_chain, p_block );
  97     if( !p_bytestream->p_block ) p_bytestream->p_block = p_block;
  98 }
  99
 100 VLC_USED
 101 static inline block_t *block_BytestreamPop( block_bytestream_t *p_bytestream )
 102 {
 103     block_t *p_block;
 104
 105     block_BytestreamFlush( p_bytestream );
 106
 107     p_block = p_bytestream->p_block;
 108     if( p_block == NULL )
 109     {
 110         return NULL;
 111     }
 112     else if( !p_block->p_next )
 113     {
 114         p_block->p_buffer += p_bytestream->i_offset;
 115         p_block->i_buffer -= p_bytestream->i_offset;
 116         p_bytestream->i_offset = 0;
 117         p_bytestream->p_chain = p_bytestream->p_block = NULL;
 118         return p_block;
 119     }
 120
 121     while( p_block->p_next && p_block->p_next->p_next )
 122         p_block = p_block->p_next;
 123
 124     block_t *p_block_old = p_block;
 125     p_block = p_block->p_next;
 126     p_block_old->p_next = NULL;
 127
 128     return p_block;
 129 }
 130
 131 static inline int block_SkipByte( block_bytestream_t *p_bytestream )
 132 {
 133     /* Most common case first */
 134     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
 135     {
 136         p_bytestream->i_offset++;
 137         return VLC_SUCCESS;
 138     }
 139     else
 140     {
 141         block_t *p_block;
 142
 143         /* Less common case which is also slower */
 144         for( p_block = p_bytestream->p_block->p_next;
 145              p_block != NULL; p_block = p_block->p_next )
 146         {
 147             if( p_block->i_buffer )
 148             {
 149                 p_bytestream->i_offset = 1;
 150                 p_bytestream->p_block = p_block;
 151                 return VLC_SUCCESS;
 152             }
 153         }
 154     }
 155
 156     /* Not enough data, bail out */
 157     return VLC_EGENERIC;
 158 }
 159
 160 static inline int block_PeekByte( block_bytestream_t *p_bytestream,
 161                                   uint8_t *p_data )
 162 {
 163     /* Most common case first */
 164     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
 165     {
 166         *p_data = p_bytestream->p_block->p_buffer[p_bytestream->i_offset];
 167         return VLC_SUCCESS;
 168     }
 169     else
 170     {
 171         block_t *p_block;
 172
 173         /* Less common case which is also slower */
 174         for( p_block = p_bytestream->p_block->p_next;
 175              p_block != NULL; p_block = p_block->p_next )
 176         {
 177             if( p_block->i_buffer )
 178             {
 179                 *p_data = p_block->p_buffer[0];
 180                 return VLC_SUCCESS;
 181             }
 182         }
 183     }
 184
 185     /* Not enough data, bail out */
 186     return VLC_EGENERIC;
 187 }
 188
 189 static inline int block_GetByte( block_bytestream_t *p_bytestream,
 190                                  uint8_t *p_data )
 191 {
 192     /* Most common case first */
 193     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
 194     {
 195         *p_data = p_bytestream->p_block->p_buffer[p_bytestream->i_offset];
 196         p_bytestream->i_offset++;
 197         return VLC_SUCCESS;
 198     }
 199     else
 200     {
 201         block_t *p_block;
 202
 203         /* Less common case which is also slower */
 204         for( p_block = p_bytestream->p_block->p_next;
 205              p_block != NULL; p_block = p_block->p_next )
 206         {
 207             if( p_block->i_buffer )
 208             {
 209                 *p_data = p_block->p_buffer[0];
 210                 p_bytestream->i_offset = 1;
 211                 p_bytestream->p_block = p_block;
 212                 return VLC_SUCCESS;
 213             }
 214         }
 215     }
 216
 217     /* Not enough data, bail out */
 218     return VLC_EGENERIC;
 219 }
 220
 221 static inline int block_WaitBytes( block_bytestream_t *p_bytestream,
 222                                    size_t i_data )
 223 {
 224     block_t *p_block;
 225     size_t i_offset, i_copy, i_size;
 226
 227     /* Check we have that much data */
 228     i_offset = p_bytestream->i_offset;
 229     i_size = i_data;
 230     i_copy = 0;
 231     for( p_block = p_bytestream->p_block;
 232          p_block != NULL; p_block = p_block->p_next )
 233     {
 234         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 235         i_size -= i_copy;
 236         i_offset = 0;
 237
 238         if( !i_size ) break;
 239     }
 240
 241     if( i_size )
 242     {
 243         /* Not enough data, bail out */
 244         return VLC_EGENERIC;
 245     }
 246     return VLC_SUCCESS;
 247 }
 248
 249 static inline int block_SkipBytes( block_bytestream_t *p_bytestream,
 250                                    size_t i_data )
 251 {
 252     block_t *p_block;
 253     size_t i_offset, i_copy;
 254
 255     /* Check we have that much data */
 256     i_offset = p_bytestream->i_offset;
 257     i_copy = 0;
 258     for( p_block = p_bytestream->p_block;
 259          p_block != NULL; p_block = p_block->p_next )
 260     {
 261         i_copy = __MIN( i_data, p_block->i_buffer - i_offset );
 262         i_data -= i_copy;
 263
 264         if( !i_data ) break;
 265
 266         i_offset = 0;
 267     }
 268
 269     if( i_data )
 270     {
 271         /* Not enough data, bail out */
 272         return VLC_EGENERIC;
 273     }
 274
 275     p_bytestream->p_block = p_block;
 276     p_bytestream->i_offset = i_offset + i_copy;
 277     return VLC_SUCCESS;
 278 }
 279
 280 static inline int block_PeekBytes( block_bytestream_t *p_bytestream,
 281                                    uint8_t *p_data, size_t i_data )
 282 {
 283     block_t *p_block;
 284     size_t i_offset, i_copy, i_size;
 285
 286     /* Check we have that much data */
 287     i_offset = p_bytestream->i_offset;
 288     i_size = i_data;
 289     i_copy = 0;
 290     for( p_block = p_bytestream->p_block;
 291          p_block != NULL; p_block = p_block->p_next )
 292     {
 293         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 294         i_size -= i_copy;
 295         i_offset = 0;
 296
 297         if( !i_size ) break;
 298     }
 299
 300     if( i_size )
 301     {
 302         /* Not enough data, bail out */
 303         return VLC_EGENERIC;
 304     }
 305
 306     /* Copy the data */
 307     i_offset = p_bytestream->i_offset;
 308     i_size = i_data;
 309     i_copy = 0;
 310     for( p_block = p_bytestream->p_block;
 311          p_block != NULL; p_block = p_block->p_next )
 312     {
 313         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 314         i_size -= i_copy;
 315
 316         if( i_copy )
 317         {
 318             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 319             p_data += i_copy;
 320         }
 321
 322         i_offset = 0;
 323
 324         if( !i_size ) break;
 325     }
 326
 327     return VLC_SUCCESS;
 328 }
 329
 330 static inline int block_GetBytes( block_bytestream_t *p_bytestream,
 331                                   uint8_t *p_data, size_t i_data )
 332 {
 333     block_t *p_block;
 334     size_t i_offset, i_copy, i_size;
 335
 336     /* Check we have that much data */
 337     i_offset = p_bytestream->i_offset;
 338     i_size = i_data;
 339     i_copy = 0;
 340     for( p_block = p_bytestream->p_block;
 341          p_block != NULL; p_block = p_block->p_next )
 342     {
 343         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 344         i_size -= i_copy;
 345         i_offset = 0;
 346
 347         if( !i_size ) break;
 348     }
 349
 350     if( i_size )
 351     {
 352         /* Not enough data, bail out */
 353         return VLC_EGENERIC;
 354     }
 355
 356     /* Copy the data */
 357     i_offset = p_bytestream->i_offset;
 358     i_size = i_data;
 359     i_copy = 0;
 360     for( p_block = p_bytestream->p_block;
 361          p_block != NULL; p_block = p_block->p_next )
 362     {
 363         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 364         i_size -= i_copy;
 365
 366         if( i_copy )
 367         {
 368             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 369             p_data += i_copy;
 370         }
 371
 372         if( !i_size ) break;
 373
 374         i_offset = 0;
 375     }
 376
 377     p_bytestream->p_block = p_block;
 378     p_bytestream->i_offset = i_offset + i_copy;
 379
 380     return VLC_SUCCESS;
 381 }
 382
 383 static inline int block_PeekOffsetBytes( block_bytestream_t *p_bytestream,
 384     size_t i_peek_offset, uint8_t *p_data, size_t i_data )
 385 {
 386     block_t *p_block;
 387     size_t i_offset, i_copy, i_size;
 388
 389     /* Check we have that much data */
 390     i_offset = p_bytestream->i_offset;
 391     i_size = i_data + i_peek_offset;
 392     i_copy = 0;
 393     for( p_block = p_bytestream->p_block;
 394          p_block != NULL; p_block = p_block->p_next )
 395     {
 396         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 397         i_size -= i_copy;
 398         i_offset = 0;
 399
 400         if( !i_size ) break;
 401     }
 402
 403     if( i_size )
 404     {
 405         /* Not enough data, bail out */
 406         return VLC_EGENERIC;
 407     }
 408
 409     /* Find the right place */
 410     i_offset = p_bytestream->i_offset;
 411     i_size = i_peek_offset;
 412     i_copy = 0;
 413     for( p_block = p_bytestream->p_block;
 414          p_block != NULL; p_block = p_block->p_next )
 415     {
 416         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 417         i_size -= i_copy;
 418
 419         if( !i_size ) break;
 420
 421         i_offset = 0;
 422     }
 423
 424     /* Copy the data */
 425     i_offset += i_copy;
 426     i_size = i_data;
 427     i_copy = 0;
 428     for( ; p_block != NULL; p_block = p_block->p_next )
 429     {
 430         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 431         i_size -= i_copy;
 432
 433         if( i_copy )
 434         {
 435             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 436             p_data += i_copy;
 437         }
 438
 439         i_offset = 0;
 440
 441         if( !i_size ) break;
 442     }
 443
 444     return VLC_SUCCESS;
 445 }
 446
 447 static inline int block_FindStartcodeFromOffset(
 448     block_bytestream_t *p_bytestream, size_t *pi_offset,
 449     const uint8_t *p_startcode, int i_startcode_length )
 450 {
 451     block_t *p_block, *p_block_backup = 0;
 452     int i_size = 0;
 453     size_t i_offset, i_offset_backup = 0;
 454     int i_caller_offset_backup = 0, i_match;
 455
 456     /* Find the right place */
 457     i_size = *pi_offset + p_bytestream->i_offset;
 458     for( p_block = p_bytestream->p_block;
 459          p_block != NULL; p_block = p_block->p_next )
 460     {
 461         i_size -= p_block->i_buffer;
 462         if( i_size < 0 ) break;
 463     }
 464
 465     if( i_size >= 0 )
 466     {
 467         /* Not enough data, bail out */
 468         return VLC_EGENERIC;
 469     }
 470
 471     /* Begin the search.
 472      * We first look for an occurrence of the 1st startcode byte and
 473      * if found, we do a more thorough check. */
 474     i_size += p_block->i_buffer;
 475     *pi_offset -= i_size;
 476     i_match = 0;
 477     for( ; p_block != NULL; p_block = p_block->p_next )
 478     {
 479         for( i_offset = i_size; i_offset < p_block->i_buffer; i_offset++ )
 480         {
 481             if( p_block->p_buffer[i_offset] == p_startcode[i_match] )
 482             {
 483                 if( !i_match )
 484                 {
 485                     p_block_backup = p_block;
 486                     i_offset_backup = i_offset;
 487                     i_caller_offset_backup = *pi_offset;
 488                 }
 489
 490                 if( i_match + 1 == i_startcode_length )
 491                 {
 492                     /* We have it */
 493                     *pi_offset += i_offset - i_match;
 494                     return VLC_SUCCESS;
 495                 }
 496
 497                 i_match++;
 498             }
 499             else if ( i_match )
 500             {
 501                 /* False positive */
 502                 p_block = p_block_backup;
 503                 i_offset = i_offset_backup;
 504                 *pi_offset = i_caller_offset_backup;
 505                 i_match = 0;
 506             }
 507
 508         }
 509         i_size = 0;
 510         *pi_offset += i_offset;
 511     }
 512
 513     *pi_offset -= i_match;
 514     return VLC_EGENERIC;
 515 }
 516
 517 #endif /* VLC_BLOCK_HELPER_H */