vlc_block_helper.h: fix weird indentation.
[vlc.git] / 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     /* No buffer given, just skip the data */
378     p_bytestream->p_block = p_block;
379     p_bytestream->i_offset = i_offset + i_copy;
380
381     return VLC_SUCCESS;
382 }
383
384 static inline int block_PeekOffsetBytes( block_bytestream_t *p_bytestream,
385     size_t i_peek_offset, uint8_t *p_data, size_t i_data )
386 {
387     block_t *p_block;
388     size_t i_offset, i_copy, i_size;
389
390     /* Check we have that much data */
391     i_offset = p_bytestream->i_offset;
392     i_size = i_data + i_peek_offset;
393     i_copy = 0;
394     for( p_block = p_bytestream->p_block;
395          p_block != NULL; p_block = p_block->p_next )
396     {
397         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
398         i_size -= i_copy;
399         i_offset = 0;
400
401         if( !i_size ) break;
402     }
403
404     if( i_size )
405     {
406         /* Not enough data, bail out */
407         return VLC_EGENERIC;
408     }
409
410     /* Find the right place */
411     i_offset = p_bytestream->i_offset;
412     i_size = i_peek_offset;
413     i_copy = 0;
414     for( p_block = p_bytestream->p_block;
415          p_block != NULL; p_block = p_block->p_next )
416     {
417         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
418         i_size -= i_copy;
419
420         if( !i_size ) break;
421
422         i_offset = 0;
423     }
424
425     /* Copy the data */
426     i_offset += i_copy;
427     i_size = i_data;
428     i_copy = 0;
429     for( ; p_block != NULL; p_block = p_block->p_next )
430     {
431         i_copy = __MIN( i_size, p_block->i_buffer - i_offset );
432         i_size -= i_copy;
433
434         if( i_copy )
435         {
436             memcpy( p_data, p_block->p_buffer + i_offset, i_copy );
437             p_data += i_copy;
438         }
439
440         i_offset = 0;
441
442         if( !i_size ) break;
443     }
444
445     return VLC_SUCCESS;
446 }
447
448 static inline int block_FindStartcodeFromOffset(
449     block_bytestream_t *p_bytestream, size_t *pi_offset,
450     const uint8_t *p_startcode, int i_startcode_length )
451 {
452     block_t *p_block, *p_block_backup = 0;
453     int i_size = 0;
454     size_t i_offset, i_offset_backup = 0;
455     int i_caller_offset_backup = 0, i_match;
456
457     /* Find the right place */
458     i_size = *pi_offset + p_bytestream->i_offset;
459     for( p_block = p_bytestream->p_block;
460          p_block != NULL; p_block = p_block->p_next )
461     {
462         i_size -= p_block->i_buffer;
463         if( i_size < 0 ) break;
464     }
465
466     if( i_size >= 0 )
467     {
468         /* Not enough data, bail out */
469         return VLC_EGENERIC;
470     }
471
472     /* Begin the search.
473      * We first look for an occurrence of the 1st startcode byte and
474      * if found, we do a more thorough check. */
475     i_size += p_block->i_buffer;
476     *pi_offset -= i_size;
477     i_match = 0;
478     for( ; p_block != NULL; p_block = p_block->p_next )
479     {
480         for( i_offset = i_size; i_offset < p_block->i_buffer; i_offset++ )
481         {
482             if( p_block->p_buffer[i_offset] == p_startcode[i_match] )
483             {
484                 if( !i_match )
485                 {
486                     p_block_backup = p_block;
487                     i_offset_backup = i_offset;
488                     i_caller_offset_backup = *pi_offset;
489                 }
490
491                 if( i_match + 1 == i_startcode_length )
492                 {
493                     /* We have it */
494                     *pi_offset += i_offset - i_match;
495                     return VLC_SUCCESS;
496                 }
497
498                 i_match++;
499             }
500             else if ( i_match )
501             {
502                 /* False positive */
503                 p_block = p_block_backup;
504                 i_offset = i_offset_backup;
505                 *pi_offset = i_caller_offset_backup;
506                 i_match = 0;
507             }
508
509         }
510         i_size = 0;
511         *pi_offset += i_offset;
512     }
513
514     *pi_offset -= i_match;
515     return VLC_EGENERIC;
516 }
517
518 #endif /* VLC_BLOCK_HELPER_H */