videolan
/
vlc
mirror of https://gitea.goldendeliverer.com/videolan/vlc.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
Browse Source

vlc_bits: use vlc_common and guards against failed realloc 

refs #14193
pull/29/head
Francois Cartegnie 12 years ago
parent
0902f0d622
commit
0eba4c32a0
1 changed files with 74 additions and 85 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 159
      include/vlc_bits.h

159
include/vlc_bits.h
View File

@ -26,6 +26,7 @@
#ifndef VLC_BITS_H
#define VLC_BITS_H 1
#include <vlc_common.h>
#include <vlc_block.h>
/**
@ -204,135 +205,123 @@ static inline void bs_align_1( bs_t *s )
}
}
static inline int bo_init(bo_t *p_bo, int i_size)
static inline bool bo_init(bo_t *p_bo, int i_size)
{
p_bo->b = block_Alloc(i_size);
if (!p_bo->b)
return VLC_ENOMEM;
return false;
p_bo->b->i_buffer = 0;
p_bo->basesize = i_size;
return VLC_SUCCESS;
return true;
}
static inline void bo_set_8(bo_t *p_bo, size_t i_offset, uint8_t i)
static inline void bo_free(bo_t *p_bo)
{
size_t i_size = p_bo->b->i_size - (p_bo->b->p_buffer - p_bo->b->p_start);
if (i_offset >= i_size)
if(!p_bo)
return;
if(p_bo->b)
block_Release(p_bo->b);
free(p_bo);
}
static inline int bo_extend(bo_t *p_bo, size_t i_total)
{
if(!p_bo->b)
return false;
const size_t i_size = p_bo->b->i_size - (p_bo->b->p_buffer - p_bo->b->p_start);
if (i_total >= i_size)
{
int i_growth = p_bo->basesize;
while(i_offset >= i_size + i_growth)
while(i_total >= i_size + i_growth)
i_growth += p_bo->basesize;
int i = p_bo->b->i_buffer; /* Realloc would set payload size == buffer size */
p_bo->b = block_Realloc(p_bo->b, 0, i_size + i_growth);
if (!p_bo->b)
return;
return false;
p_bo->b->i_buffer = i;
}
p_bo->b->p_buffer[i_offset] = i;
}
static inline void bo_add_8(bo_t *p_bo, uint8_t i)
{
bo_set_8( p_bo, p_bo->b->i_buffer, i );
p_bo->b->i_buffer++;
}
static inline void bo_add_16be(bo_t *p_bo, uint16_t i)
{
bo_add_8(p_bo, ((i >> 8) &0xff));
bo_add_8(p_bo, i &0xff);
return true;
}
static inline void bo_add_16le(bo_t *p_bo, uint16_t i)
{
bo_add_8(p_bo, i &0xff);
bo_add_8(p_bo, ((i >> 8) &0xff));
}
#define BO_SET_DECL_S(func, handler, type) static inline bool func(bo_t *p_bo, size_t i_offset, type val)\
{\
if (!bo_extend(p_bo, i_offset + sizeof(type)))\
return false;\
handler(&p_bo->b->p_buffer[i_offset], val);\
return true;\
}
static inline void bo_set_16be(bo_t *p_bo, int i_offset, uint16_t i)
{
bo_set_8(p_bo, i_offset, ((i >> 8) &0xff));
bo_set_8(p_bo, i_offset + 1, i &0xff);
}
#define BO_ADD_DECL_S(func, handler, type) static inline bool func(bo_t *p_bo, type val)\
{\
if(!p_bo->b || !handler(p_bo, p_bo->b->i_buffer, val))\
return false;\
p_bo->b->i_buffer += sizeof(type);\
return true;\
}
static inline void bo_set_16le(bo_t *p_bo, int i_offset, uint16_t i)
{
bo_set_8(p_bo, i_offset, i &0xff);
bo_set_8(p_bo, i_offset + 1, ((i >> 8) &0xff));
}
#define BO_FUNC_DECL(suffix, handler, type ) \
BO_SET_DECL_S( bo_set_ ## suffix ## be, handler ## BE, type )\
BO_SET_DECL_S( bo_set_ ## suffix ## le, handler ## LE, type )\
BO_ADD_DECL_S( bo_add_ ## suffix ## be, bo_set_ ## suffix ## be, type )\
BO_ADD_DECL_S( bo_add_ ## suffix ## le, bo_set_ ## suffix ## le, type )
static inline void bo_add_24be(bo_t *p_bo, uint32_t i)
static inline bool bo_set_8(bo_t *p_bo, size_t i_offset, uint8_t i)
{
bo_add_8(p_bo, ((i >> 16) &0xff));
bo_add_8(p_bo, ((i >> 8) &0xff));
bo_add_8(p_bo, (i &0xff));
if (!bo_extend(p_bo, i_offset + 1))
return false;
p_bo->b->p_buffer[i_offset] = i;
return true;
}
static inline void bo_add_32be(bo_t *p_bo, uint32_t i)
static inline bool bo_add_8(bo_t *p_bo, uint8_t i)
{
bo_add_16be(p_bo, ((i >> 16) &0xffff));
bo_add_16be(p_bo, i &0xffff);
if(!p_bo->b || !bo_set_8( p_bo, p_bo->b->i_buffer, i ))
return false;
p_bo->b->i_buffer++;
return true;
}
static inline void bo_add_32le(bo_t *p_bo, uint32_t i)
{
bo_add_16le(p_bo, i &0xffff);
bo_add_16le(p_bo, ((i >> 16) &0xffff));
}
/* declares all bo_[set,add]_[16,32,64] */
BO_FUNC_DECL( 16, SetW, uint16_t )
BO_FUNC_DECL( 32, SetDW, uint32_t )
BO_FUNC_DECL( 64, SetQW, uint64_t )
static inline void bo_set_32be(bo_t *p_bo, int i_offset, uint32_t i)
{
bo_set_16be(p_bo, i_offset, ((i >> 16) &0xffff));
bo_set_16be(p_bo, i_offset + 2, i &0xffff);
}
#undef BO_FUNC_DECL
#undef BO_SET_DECL_S
#undef BO_ADD_DECL_S
static inline void bo_set_32le(bo_t *p_bo, int i_offset, uint32_t i)
static inline bool bo_add_24be(bo_t *p_bo, uint32_t i)
{
bo_set_16le(p_bo, i_offset, i &0xffff);
bo_set_16le(p_bo, i_offset + 2, ((i >> 16) &0xffff));
if(!p_bo->b || !bo_extend(p_bo, p_bo->b->i_buffer + 3))
return false;
p_bo->b->p_buffer[p_bo->b->i_buffer++] = ((i >> 16) & 0xff);
p_bo->b->p_buffer[p_bo->b->i_buffer++] = ((i >> 8) & 0xff);
p_bo->b->p_buffer[p_bo->b->i_buffer++] = (i & 0xff);
return true;
}
static inline void bo_swap_32be (bo_t *p_bo, int i_pos, uint32_t i)
static inline void bo_swap_32be (bo_t *p_bo, size_t i_pos, uint32_t i)
{
if (!p_bo->b || p_bo->b->i_buffer < i_pos + 4)
return;
p_bo->b->p_buffer[i_pos ] = (i >> 24)&0xff;
p_bo->b->p_buffer[i_pos + 1] = (i >> 16)&0xff;
p_bo->b->p_buffer[i_pos + 2] = (i >> 8)&0xff;
p_bo->b->p_buffer[i_pos + 3] = (i )&0xff;
}
static inline void bo_set_64be(bo_t *p_bo, int i_offset, uint64_t i)
{
bo_set_32be(p_bo, i_offset, ((i >> 32) &0xffffffff));
bo_set_32be(p_bo, i_offset + 4, i &0xffffffff);
}
static inline void bo_add_64be(bo_t *p_bo, uint64_t i)
static inline bool bo_add_mem(bo_t *p_bo, size_t i_size, const void *p_mem)
{
bo_add_32be(p_bo, ((i >> 32) &0xffffffff));
bo_add_32be(p_bo, i &0xffffffff);
if(!p_bo->b || !bo_extend(p_bo, p_bo->b->i_buffer + i_size))
return false;
memcpy(&p_bo->b->p_buffer[p_bo->b->i_buffer], p_mem, i_size);
p_bo->b->i_buffer += i_size;
return true;
}
static inline void bo_add_64le(bo_t *p_bo, uint64_t i)
{
bo_add_32le(p_bo, i &0xffffffff);
bo_add_32le(p_bo, ((i >> 32) &0xffffffff));
}
static inline void bo_add_fourcc(bo_t *p_bo, const char *fcc)
{
bo_add_8(p_bo, fcc[0]);
bo_add_8(p_bo, fcc[1]);
bo_add_8(p_bo, fcc[2]);
bo_add_8(p_bo, fcc[3]);
}
static inline void bo_add_mem(bo_t *p_bo, int i_size, const uint8_t *p_mem)
{
for (int i = 0; i < i_size; i++)
bo_add_8(p_bo, p_mem[i]);
}
#define bo_add_fourcc(p_bo, fcc) bo_add_mem(p_bo, 4, fcc)
#endif

Write Preview
Loading…
Cancel
Save