git.sesse.net Git - vlc/blob - include/vlc_block_helper.h

   1 /*****************************************************************************
   2  * vlc_block_helper.h: Helper functions for data blocks management.
   3  *****************************************************************************
   4  * Copyright (C) 2003 VideoLAN
   5  * $Id: vlc_block_helper.h,v 1.1 2003/09/30 20:23:03 gbazin Exp $
   6  *
   7  * Authors: Gildas Bazin <gbazin@netcourrier.com>
   8  *
   9  * This program is free software; you can redistribute it and/or modify
  10  * it under the terms of the GNU General Public License as published by
  11  * the Free Software Foundation; either version 2 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 General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU General Public License
  20  * along with this program; if not, write to the Free Software
  21  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
  22  *****************************************************************************/
  23
  24 #ifndef _VLC_BLOCK_HELPER_H
  25 #define _VLC_BLOCK_HELPER_H 1
  26
  27 typedef struct block_bytestream_t
  28 {
  29     block_t             *p_chain;
  30     block_t             *p_block;
  31     int                 i_offset;
  32 } block_bytestream_t;
  33
  34 #define block_BytestreamInit( a, b, c ) __block_BytestreamInit( VLC_OBJECT(a), b, c )
  35
  36 /*****************************************************************************
  37  * block_bytestream_t management
  38  *****************************************************************************/
  39 static inline block_bytestream_t __block_BytestreamInit( vlc_object_t *p_obj,
  40                                            block_t *p_block, int i_offset )
  41 {
  42     block_bytestream_t bytestream;
  43
  44     bytestream.i_offset = i_offset;
  45     bytestream.p_block = p_block;
  46     bytestream.p_chain = p_block;
  47
  48     return bytestream;
  49 }
  50
  51 static inline block_t *block_BytestreamFlush( block_bytestream_t *p_bytestream)
  52 {
  53     while( p_bytestream->p_chain != p_bytestream->p_block )
  54     {
  55         block_t *p_next;
  56         p_next = p_bytestream->p_chain->p_next;
  57         p_bytestream->p_chain->pf_release( p_bytestream->p_chain );
  58         p_bytestream->p_chain = p_next;
  59     }
  60
  61     return p_bytestream->p_chain;
  62 }
  63
  64 static inline mtime_t block_BytestreamPTS( block_bytestream_t *p_bytestream )
  65 {
  66     while( p_bytestream->p_chain != p_bytestream->p_block )
  67     {
  68         block_t *p_next;
  69         p_next = p_bytestream->p_chain->p_next;
  70         p_bytestream->p_chain->pf_release( p_bytestream->p_chain );
  71         p_bytestream->p_chain = p_next;
  72     }
  73
  74     return p_bytestream->p_chain;
  75 }
  76
  77 static inline int block_SkipByte( block_bytestream_t *p_bytestream )
  78 {
  79     /* Most common case first */
  80     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
  81     {
  82         p_bytestream->i_offset++;
  83         return VLC_SUCCESS;
  84     }
  85     else
  86     {
  87         block_t *p_block;
  88
  89         /* Less common case which is also slower */
  90         for( p_block = p_bytestream->p_block->p_next;
  91              p_block != NULL; p_block = p_block->p_next )
  92         {
  93             if( p_block->i_buffer )
  94             {
  95                 p_bytestream->i_offset = 1;
  96                 p_bytestream->p_block = p_block;
  97                 return VLC_SUCCESS;
  98             }
  99         }
 100     }
 101
 102     /* Not enough data, bail out */
 103     return VLC_EGENERIC;
 104 }
 105
 106 static inline int block_PeekByte( block_bytestream_t *p_bytestream,
 107                                   uint8_t *p_data )
 108 {
 109     /* Most common case first */
 110     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
 111     {
 112         *p_data = p_bytestream->p_block->p_buffer[p_bytestream->i_offset];
 113         return VLC_SUCCESS;
 114     }
 115     else
 116     {
 117         block_t *p_block;
 118
 119         /* Less common case which is also slower */
 120         for( p_block = p_bytestream->p_block->p_next;
 121              p_block != NULL; p_block = p_block->p_next )
 122         {
 123             if( p_block->i_buffer )
 124             {
 125                 *p_data = p_block->p_buffer[0];
 126                 return VLC_SUCCESS;
 127             }
 128         }
 129     }
 130
 131     /* Not enough data, bail out */
 132     return VLC_EGENERIC;
 133 }
 134
 135 static inline int block_GetByte( block_bytestream_t *p_bytestream,
 136                                  uint8_t *p_data )
 137 {
 138     /* Most common case first */
 139     if( p_bytestream->p_block->i_buffer - p_bytestream->i_offset )
 140     {
 141         *p_data = p_bytestream->p_block->p_buffer[p_bytestream->i_offset];
 142         p_bytestream->i_offset++;
 143         return VLC_SUCCESS;
 144     }
 145     else
 146     {
 147         block_t *p_block;
 148
 149         /* Less common case which is also slower */
 150         for( p_block = p_bytestream->p_block->p_next;
 151              p_block != NULL; p_block = p_block->p_next )
 152         {
 153             if( p_block->i_buffer )
 154             {
 155                 *p_data = p_block->p_buffer[0];
 156                 p_bytestream->i_offset = 1;
 157                 p_bytestream->p_block = p_block;
 158                 return VLC_SUCCESS;
 159             }
 160         }
 161     }
 162
 163     /* Not enough data, bail out */
 164     return VLC_EGENERIC;
 165 }
 166
 167 static inline int block_SkipBytes( block_bytestream_t *p_bytestream,
 168                                    int i_data )
 169 {
 170     block_t *p_block;
 171     int i_offset, i_copy;
 172
 173     /* Check we have that much data */
 174     i_offset = p_bytestream->i_offset;
 175     i_copy = 0;
 176     for( p_block = p_bytestream->p_block;
 177          p_block != NULL; p_block = p_block->p_next )
 178     {
 179         i_copy = __MIN( i_data, p_block->i_buffer - i_offset );
 180         i_data -= i_copy;
 181         i_offset = 0;
 182
 183         if( !i_data ) break;
 184     }
 185
 186     if( i_data )
 187     {
 188         /* Not enough data, bail out */
 189         return VLC_EGENERIC;
 190     }
 191
 192     p_bytestream->p_block = p_block;
 193     p_bytestream->i_offset = i_copy;
 194     return VLC_SUCCESS;
 195 }
 196
 197 static inline int block_PeekBytes( block_bytestream_t *p_bytestream,
 198                                    uint8_t *p_data, int i_data )
 199 {
 200     block_t *p_block;
 201     int i_offset, i_copy, i_size;
 202
 203     /* Check we have that much data */
 204     i_offset = p_bytestream->i_offset;
 205     i_size = i_data;
 206     i_copy = 0;
 207     for( p_block = p_bytestream->p_block;
 208          p_block != NULL; p_block = p_block->p_next )
 209     {
 210         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 211         i_size -= i_copy;
 212         i_offset = 0;
 213
 214         if( !i_size ) break;
 215     }
 216
 217     if( i_size )
 218     {
 219         /* Not enough data, bail out */
 220         return VLC_EGENERIC;
 221     }
 222
 223     /* Copy the data */
 224     i_offset = p_bytestream->i_offset;
 225     i_size = i_data;
 226     i_copy = 0;
 227     for( p_block = p_bytestream->p_block;
 228          p_block != NULL; p_block = p_block->p_next )
 229     {
 230         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 231         i_size -= i_copy;
 232
 233         if( i_copy )
 234         {
 235             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 236             p_data += i_copy;
 237         }
 238
 239         i_offset = 0;
 240
 241         if( !i_size ) break;
 242     }
 243
 244     return VLC_SUCCESS;
 245 }
 246
 247 static inline int block_GetBytes( block_bytestream_t *p_bytestream,
 248                                   uint8_t *p_data, int i_data )
 249 {
 250     block_t *p_block;
 251     int i_offset, i_copy, i_size;
 252
 253     /* Check we have that much data */
 254     i_offset = p_bytestream->i_offset;
 255     i_size = i_data;
 256     i_copy = 0;
 257     for( p_block = p_bytestream->p_block;
 258          p_block != NULL; p_block = p_block->p_next )
 259     {
 260         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 261         i_size -= i_copy;
 262         i_offset = 0;
 263
 264         if( !i_size ) break;
 265     }
 266
 267     if( i_size )
 268     {
 269         /* Not enough data, bail out */
 270         return VLC_EGENERIC;
 271     }
 272
 273     /* Copy the data */
 274     i_offset = p_bytestream->i_offset;
 275     i_size = i_data;
 276     i_copy = 0;
 277     for( p_block = p_bytestream->p_block;
 278          p_block != NULL; p_block = p_block->p_next )
 279     {
 280         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 281         i_size -= i_copy;
 282
 283         if( i_copy )
 284         {
 285             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 286             p_data += i_copy;
 287         }
 288
 289         i_offset = 0;
 290
 291         if( !i_size ) break;
 292     }
 293
 294     /* No buffer given, just skip the data */
 295     p_bytestream->p_block = p_block;
 296     p_bytestream->i_offset = i_copy;
 297
 298     return VLC_SUCCESS;
 299 }
 300
 301 static inline int block_PeekOffsetBytes( block_bytestream_t *p_bytestream,
 302     int i_peek_offset, uint8_t *p_data, int i_data )
 303 {
 304     block_t *p_block;
 305     int i_offset, i_copy, i_size;
 306
 307     /* Check we have that much data */
 308     i_offset = p_bytestream->i_offset;
 309     i_size = i_data + i_peek_offset;
 310     i_copy = 0;
 311     for( p_block = p_bytestream->p_block;
 312          p_block != NULL; p_block = p_block->p_next )
 313     {
 314         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 315         i_size -= i_copy;
 316         i_offset = 0;
 317
 318         if( !i_size ) break;
 319     }
 320
 321     if( i_size )
 322     {
 323         /* Not enough data, bail out */
 324         return VLC_EGENERIC;
 325     }
 326
 327     /* Find the right place */
 328     i_offset = p_bytestream->i_offset;
 329     i_size = i_peek_offset;
 330     i_copy = 0;
 331     for( p_block = p_bytestream->p_block;
 332          p_block != NULL; p_block = p_block->p_next )
 333     {
 334         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 335         i_size -= i_copy;
 336         i_offset = 0;
 337
 338         if( !i_size ) break;
 339     }
 340
 341     /* Copy the data */
 342     i_offset = i_copy;
 343     i_size = i_data;
 344     i_copy = 0;
 345     for( ; p_block != NULL; p_block = p_block->p_next )
 346     {
 347         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
 348         i_size -= i_copy;
 349
 350         if( i_copy )
 351         {
 352             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
 353             p_data += i_copy;
 354         }
 355
 356         i_offset = 0;
 357
 358         if( !i_size ) break;
 359     }
 360
 361     return VLC_SUCCESS;
 362 }
 363
 364 #endif /* VLC_BLOCK_HELPER_H */