1 /*****************************************************************************
2 * vlc_block_helper.h: Helper functions for data blocks management.
3 *****************************************************************************
4 * Copyright (C) 2003 the VideoLAN team
7 * Authors: Gildas Bazin <gbazin@netcourrier.com>
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.
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.
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., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
22 *****************************************************************************/
24 #ifndef VLC_BLOCK_HELPER_H
25 #define VLC_BLOCK_HELPER_H 1
27 #include <vlc_block.h>
29 typedef struct block_bytestream_t
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? */
37 /*****************************************************************************
38 * block_bytestream_t management
39 *****************************************************************************/
40 static inline void block_BytestreamInit( block_bytestream_t
*p_bytestream
)
42 p_bytestream
->p_chain
= p_bytestream
->p_block
= NULL
;
43 p_bytestream
->i_offset
= 0;
46 static inline void block_BytestreamRelease( block_bytestream_t
*p_bytestream
)
48 for( block_t
*block
= p_bytestream
->p_chain
; block
!= NULL
; )
50 block_t
*p_next
= block
->p_next
;
52 block_Release( block
);
58 * It flush all data (read and unread) from a block_bytestream_t.
60 static inline void block_BytestreamEmpty( block_bytestream_t
*p_bytestream
)
62 block_BytestreamRelease( p_bytestream
);
63 block_BytestreamInit( p_bytestream
);
67 * It flushes all already read data from a block_bytestream_t.
69 static inline void block_BytestreamFlush( block_bytestream_t
*p_bytestream
)
71 block_t
*block
= p_bytestream
->p_chain
;
73 while( block
!= p_bytestream
->p_block
)
75 block_t
*p_next
= block
->p_next
;
77 block_Release( block
);
81 while( block
!= NULL
&& block
->i_buffer
== p_bytestream
->i_offset
)
83 block_t
*p_next
= block
->p_next
;
85 block_Release( block
);
87 p_bytestream
->i_offset
= 0;
90 p_bytestream
->p_chain
= p_bytestream
->p_block
= block
;
93 static inline void block_BytestreamPush( block_bytestream_t
*p_bytestream
,
96 block_ChainAppend( &p_bytestream
->p_chain
, p_block
);
97 if( !p_bytestream
->p_block
) p_bytestream
->p_block
= p_block
;
101 static inline block_t
*block_BytestreamPop( block_bytestream_t
*p_bytestream
)
105 block_BytestreamFlush( p_bytestream
);
107 p_block
= p_bytestream
->p_block
;
108 if( p_block
== NULL
)
112 else if( !p_block
->p_next
)
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
;
121 while( p_block
->p_next
&& p_block
->p_next
->p_next
)
122 p_block
= p_block
->p_next
;
125 block_t
*p_block_old
= p_block
;
126 p_block
= p_block
->p_next
;
127 p_block_old
->p_next
= NULL
;
133 static inline int block_SkipByte( block_bytestream_t
*p_bytestream
)
135 /* Most common case first */
136 if( p_bytestream
->p_block
->i_buffer
- p_bytestream
->i_offset
)
138 p_bytestream
->i_offset
++;
145 /* Less common case which is also slower */
146 for( p_block
= p_bytestream
->p_block
->p_next
;
147 p_block
!= NULL
; p_block
= p_block
->p_next
)
149 if( p_block
->i_buffer
)
151 p_bytestream
->i_offset
= 1;
152 p_bytestream
->p_block
= p_block
;
158 /* Not enough data, bail out */
162 static inline int block_PeekByte( block_bytestream_t
*p_bytestream
,
165 /* Most common case first */
166 if( p_bytestream
->p_block
->i_buffer
- p_bytestream
->i_offset
)
168 *p_data
= p_bytestream
->p_block
->p_buffer
[p_bytestream
->i_offset
];
175 /* Less common case which is also slower */
176 for( p_block
= p_bytestream
->p_block
->p_next
;
177 p_block
!= NULL
; p_block
= p_block
->p_next
)
179 if( p_block
->i_buffer
)
181 *p_data
= p_block
->p_buffer
[0];
187 /* Not enough data, bail out */
191 static inline int block_GetByte( block_bytestream_t
*p_bytestream
,
194 /* Most common case first */
195 if( p_bytestream
->p_block
->i_buffer
- p_bytestream
->i_offset
)
197 *p_data
= p_bytestream
->p_block
->p_buffer
[p_bytestream
->i_offset
];
198 p_bytestream
->i_offset
++;
205 /* Less common case which is also slower */
206 for( p_block
= p_bytestream
->p_block
->p_next
;
207 p_block
!= NULL
; p_block
= p_block
->p_next
)
209 if( p_block
->i_buffer
)
211 *p_data
= p_block
->p_buffer
[0];
212 p_bytestream
->i_offset
= 1;
213 p_bytestream
->p_block
= p_block
;
219 /* Not enough data, bail out */
223 static inline int block_WaitBytes( block_bytestream_t
*p_bytestream
,
227 size_t i_offset
, i_copy
, i_size
;
229 /* Check we have that much data */
230 i_offset
= p_bytestream
->i_offset
;
233 for( p_block
= p_bytestream
->p_block
;
234 p_block
!= NULL
; p_block
= p_block
->p_next
)
236 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
245 /* Not enough data, bail out */
251 static inline int block_SkipBytes( block_bytestream_t
*p_bytestream
,
255 size_t i_offset
, i_copy
;
257 /* Check we have that much data */
258 i_offset
= p_bytestream
->i_offset
;
260 for( p_block
= p_bytestream
->p_block
;
261 p_block
!= NULL
; p_block
= p_block
->p_next
)
263 i_copy
= __MIN( i_data
, p_block
->i_buffer
- i_offset
);
273 /* Not enough data, bail out */
277 p_bytestream
->p_block
= p_block
;
278 p_bytestream
->i_offset
= i_offset
+ i_copy
;
282 static inline int block_PeekBytes( block_bytestream_t
*p_bytestream
,
283 uint8_t *p_data
, size_t i_data
)
286 size_t i_offset
, i_copy
, i_size
;
288 /* Check we have that much data */
289 i_offset
= p_bytestream
->i_offset
;
292 for( p_block
= p_bytestream
->p_block
;
293 p_block
!= NULL
; p_block
= p_block
->p_next
)
295 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
304 /* Not enough data, bail out */
309 i_offset
= p_bytestream
->i_offset
;
312 for( p_block
= p_bytestream
->p_block
;
313 p_block
!= NULL
; p_block
= p_block
->p_next
)
315 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
320 memcpy( p_data
, p_block
->p_buffer
+ i_offset
, i_copy
);
332 static inline int block_GetBytes( block_bytestream_t
*p_bytestream
,
333 uint8_t *p_data
, size_t i_data
)
336 size_t i_offset
, i_copy
, i_size
;
338 /* Check we have that much data */
339 i_offset
= p_bytestream
->i_offset
;
342 for( p_block
= p_bytestream
->p_block
;
343 p_block
!= NULL
; p_block
= p_block
->p_next
)
345 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
354 /* Not enough data, bail out */
359 i_offset
= p_bytestream
->i_offset
;
362 for( p_block
= p_bytestream
->p_block
;
363 p_block
!= NULL
; p_block
= p_block
->p_next
)
365 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
370 memcpy( p_data
, p_block
->p_buffer
+ i_offset
, i_copy
);
379 /* No buffer given, just skip the data */
380 p_bytestream
->p_block
= p_block
;
381 p_bytestream
->i_offset
= i_offset
+ i_copy
;
386 static inline int block_PeekOffsetBytes( block_bytestream_t
*p_bytestream
,
387 size_t i_peek_offset
, uint8_t *p_data
, size_t i_data
)
390 size_t i_offset
, i_copy
, i_size
;
392 /* Check we have that much data */
393 i_offset
= p_bytestream
->i_offset
;
394 i_size
= i_data
+ i_peek_offset
;
396 for( p_block
= p_bytestream
->p_block
;
397 p_block
!= NULL
; p_block
= p_block
->p_next
)
399 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
408 /* Not enough data, bail out */
412 /* Find the right place */
413 i_offset
= p_bytestream
->i_offset
;
414 i_size
= i_peek_offset
;
416 for( p_block
= p_bytestream
->p_block
;
417 p_block
!= NULL
; p_block
= p_block
->p_next
)
419 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
431 for( ; p_block
!= NULL
; p_block
= p_block
->p_next
)
433 i_copy
= __MIN( i_size
, p_block
->i_buffer
- i_offset
);
438 memcpy( p_data
, p_block
->p_buffer
+ i_offset
, i_copy
);
450 static inline int block_FindStartcodeFromOffset(
451 block_bytestream_t
*p_bytestream
, size_t *pi_offset
,
452 const uint8_t *p_startcode
, int i_startcode_length
)
454 block_t
*p_block
, *p_block_backup
= 0;
456 size_t i_offset
, i_offset_backup
= 0;
457 int i_caller_offset_backup
= 0, i_match
;
459 /* Find the right place */
460 i_size
= *pi_offset
+ p_bytestream
->i_offset
;
461 for( p_block
= p_bytestream
->p_block
;
462 p_block
!= NULL
; p_block
= p_block
->p_next
)
464 i_size
-= p_block
->i_buffer
;
465 if( i_size
< 0 ) break;
470 /* Not enough data, bail out */
475 * We first look for an occurrence of the 1st startcode byte and
476 * if found, we do a more thorough check. */
477 i_size
+= p_block
->i_buffer
;
478 *pi_offset
-= i_size
;
480 for( ; p_block
!= NULL
; p_block
= p_block
->p_next
)
482 for( i_offset
= i_size
; i_offset
< p_block
->i_buffer
; i_offset
++ )
484 if( p_block
->p_buffer
[i_offset
] == p_startcode
[i_match
] )
488 p_block_backup
= p_block
;
489 i_offset_backup
= i_offset
;
490 i_caller_offset_backup
= *pi_offset
;
493 if( i_match
+ 1 == i_startcode_length
)
496 *pi_offset
+= i_offset
- i_match
;
505 p_block
= p_block_backup
;
506 i_offset
= i_offset_backup
;
507 *pi_offset
= i_caller_offset_backup
;
513 *pi_offset
+= i_offset
;
516 *pi_offset
-= i_match
;
520 #endif /* VLC_BLOCK_HELPER_H */