Chiebot-Mirror
/
FFmpeg
mirror of https://github.com/FFmpeg/FFmpeg.git
8
0
Fork 0
Code Issues Projects Releases Wiki Activity

Code clean-up for crc.c, lfg.c, log.c, random_see.d, rational.c and tree.c.

Browse Source 
Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
pull/2/head
Yordan Makariev 13 years ago committed by Ronald S. Bultje
parent 4a59eca97a
commit 425b45d4b0
6 changed files with 287 additions and 236 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. 73
      libavutil/crc.c
  2. 34
      libavutil/lfg.c
  3. 82
      libavutil/log.c
  4. 28
      libavutil/random_seed.c
  5. 110
      libavutil/rational.c
  6. 196
      libavutil/tree.c

73
libavutil/crc.c
Unescape View File

@ -56,32 +56,34 @@ static AVCRC av_crc_table[AV_CRC_MAX][257];
* @param ctx_size size of ctx in bytes
* @return <0 on failure
*/
int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){
int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size)
{
unsigned i, j;
uint32_t c;
if (bits < 8 || bits > 32 || poly >= (1LL<<bits))
if (bits < 8 || bits > 32 || poly >= (1LL << bits))
return -1;
if (ctx_size != sizeof(AVCRC)*257 && ctx_size != sizeof(AVCRC)*1024)
if (ctx_size != sizeof(AVCRC) * 257 && ctx_size != sizeof(AVCRC) * 1024)
return -1;
for (i = 0; i < 256; i++) {
if (le) {
for (c = i, j = 0; j < 8; j++)
c = (c>>1)^(poly & (-(c&1)));
c = (c >> 1) ^ (poly & (-(c & 1)));
ctx[i] = c;
} else {
for (c = i << 24, j = 0; j < 8; j++)
c = (c<<1) ^ ((poly<<(32-bits)) & (((int32_t)c)>>31) );
c = (c << 1) ^ ((poly << (32 - bits)) & (((int32_t) c) >> 31));
ctx[i] = av_bswap32(c);
}
}
ctx[256]=1;
ctx[256] = 1;
#if !CONFIG_SMALL
if(ctx_size >= sizeof(AVCRC)*1024)
if (ctx_size >= sizeof(AVCRC) * 1024)
for (i = 0; i < 256; i++)
for(j=0; j<3; j++)
ctx[256*(j+1) + i]= (ctx[256*j + i]>>8) ^ ctx[ ctx[256*j + i]&0xFF ];
for (j = 0; j < 3; j++)
ctx[256 *(j + 1) + i] =
(ctx[256 * j + i] >> 8) ^ ctx[ctx[256 * j + i] & 0xFF];
#endif
return 0;
@ -92,9 +94,10 @@ int av_crc_init(AVCRC *ctx, int le, int bits, uint32_t poly, int ctx_size){
* @param crc_id ID of a standard CRC
* @return a pointer to the CRC table or NULL on failure
*/
const AVCRC *av_crc_get_table(AVCRCId crc_id){
const AVCRC *av_crc_get_table(AVCRCId crc_id)
{
#if !CONFIG_HARDCODED_TABLES
if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id])-1])
if (!av_crc_table[crc_id][FF_ARRAY_ELEMS(av_crc_table[crc_id]) - 1])
if (av_crc_init(av_crc_table[crc_id],
av_crc_table_params[crc_id].le,
av_crc_table_params[crc_id].bits,
@ -112,46 +115,50 @@ const AVCRC *av_crc_get_table(AVCRCId crc_id){
*
* @see av_crc_init() "le" parameter
*/
uint32_t av_crc(const AVCRC *ctx, uint32_t crc, const uint8_t *buffer, size_t length){
const uint8_t *end= buffer+length;
uint32_t av_crc(const AVCRC *ctx, uint32_t crc,
const uint8_t *buffer, size_t length)
{
const uint8_t *end = buffer + length;
#if !CONFIG_SMALL
if(!ctx[256]) {
while(((intptr_t) buffer & 3) && buffer < end)
crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8);
if (!ctx[256]) {
while (((intptr_t) buffer & 3) && buffer < end)
crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
while(buffer<end-3){
crc ^= av_le2ne32(*(const uint32_t*)buffer); buffer+=4;
crc = ctx[3*256 + ( crc &0xFF)]
^ctx[2*256 + ((crc>>8 )&0xFF)]
^ctx[1*256 + ((crc>>16)&0xFF)]
^ctx[0*256 + ((crc>>24) )];
while (buffer < end - 3) {
crc ^= av_le2ne32(*(const uint32_t *) buffer); buffer += 4;
crc = ctx[3 * 256 + ( crc & 0xFF)] ^
ctx[2 * 256 + ((crc >> 8 ) & 0xFF)] ^
ctx[1 * 256 + ((crc >> 16) & 0xFF)] ^
ctx[0 * 256 + ((crc >> 24) )];
}
}
#endif
while(buffer<end)
crc = ctx[((uint8_t)crc) ^ *buffer++] ^ (crc >> 8);
while (buffer < end)
crc = ctx[((uint8_t) crc) ^ *buffer++] ^ (crc >> 8);
return crc;
}
#ifdef TEST
#undef printf
int main(void){
int main(void)
{
uint8_t buf[1999];
int i;
int p[4][3]={{AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04},
{AV_CRC_32_IEEE , 0x04C11DB7, 0xC0F5BAE0},
{AV_CRC_16_ANSI , 0x8005, 0x1FBB },
{AV_CRC_8_ATM , 0x07, 0xE3 },};
int p[4][3] = { { AV_CRC_32_IEEE_LE, 0xEDB88320, 0x3D5CDD04 },
{ AV_CRC_32_IEEE , 0x04C11DB7, 0xC0F5BAE0 },
{ AV_CRC_16_ANSI , 0x8005 , 0x1FBB },
{ AV_CRC_8_ATM , 0x07 , 0xE3 }
};
const AVCRC *ctx;
for(i=0; i<sizeof(buf); i++)
buf[i]= i+i*i;
for (i = 0; i < sizeof(buf); i++)
buf[i] = i + i * i;
for(i=0; i<4; i++){
for (i = 0; i < 4; i++) {
ctx = av_crc_get_table(p[i][0]);
printf("crc %08X =%X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
printf("crc %08X = %X\n", p[i][1], av_crc(ctx, 0, buf, sizeof(buf)));
}
return 0;
}

34
libavutil/lfg.c
Unescape View File

@ -27,19 +27,21 @@
#include "intreadwrite.h"
#include "attributes.h"
void av_cold av_lfg_init(AVLFG *c, unsigned int seed){
uint8_t tmp[16]={0};
void av_cold av_lfg_init(AVLFG *c, unsigned int seed)
{
uint8_t tmp[16] = { 0 };
int i;
for(i=8; i<64; i+=4){
AV_WL32(tmp, seed); tmp[4]=i;
av_md5_sum(tmp, tmp, 16);
c->state[i ]= AV_RL32(tmp);
c->state[i+1]= AV_RL32(tmp+4);
c->state[i+2]= AV_RL32(tmp+8);
c->state[i+3]= AV_RL32(tmp+12);
for (i = 8; i < 64; i += 4) {
AV_WL32(tmp, seed);
tmp[4] = i;
av_md5_sum(tmp, tmp, 16);
c->state[i ] = AV_RL32(tmp);
c->state[i + 1] = AV_RL32(tmp + 4);
c->state[i + 2] = AV_RL32(tmp + 8);
c->state[i + 3] = AV_RL32(tmp + 12);
}
c->index=0;
c->index = 0;
}
void av_bmg_get(AVLFG *lfg, double out[2])
@ -47,9 +49,9 @@ void av_bmg_get(AVLFG *lfg, double out[2])
double x1, x2, w;
do {
x1 = 2.0/UINT_MAX*av_lfg_get(lfg) - 1.0;
x2 = 2.0/UINT_MAX*av_lfg_get(lfg) - 1.0;
w = x1*x1 + x2*x2;
x1 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
x2 = 2.0 / UINT_MAX * av_lfg_get(lfg) - 1.0;
w = x1 * x1 + x2 * x2;
} while (w >= 1.0);
w = sqrt((-2.0 * log(w)) / w);
@ -63,7 +65,7 @@ void av_bmg_get(AVLFG *lfg, double out[2])
int main(void)
{
int x=0;
int x = 0;
int i, j;
AVLFG state;
@ -71,8 +73,8 @@ int main(void)
for (j = 0; j < 10000; j++) {
START_TIMER
for (i = 0; i < 624; i++) {
// av_log(NULL,AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
x+=av_lfg_get(&state);
//av_log(NULL, AV_LOG_ERROR, "%X\n", av_lfg_get(&state));
x += av_lfg_get(&state);
}
STOP_TIMER("624 calls of av_lfg_get");
}

82
libavutil/log.c
Unescape View File

@ -35,104 +35,116 @@ static int flags;
#if defined(_WIN32) && !defined(__MINGW32CE__)
#include <windows.h>
static const uint8_t color[] = {12,12,12,14,7,7,7};
static const uint8_t color[] = { 12, 12, 12, 14, 7, 7, 7 };
static int16_t background, attr_orig;
static HANDLE con;
#define set_color(x) SetConsoleTextAttribute(con, background | color[x])
#define reset_color() SetConsoleTextAttribute(con, attr_orig)
#else
static const uint8_t color[]={0x41,0x41,0x11,0x03,9,9,9};
#define set_color(x) fprintf(stderr, "\033[%d;3%dm", color[x]>>4, color[x]&15)
static const uint8_t color[] = { 0x41, 0x41, 0x11, 0x03, 9, 9, 9 };
#define set_color(x) fprintf(stderr, "\033[%d;3%dm", color[x] >> 4, color[x]&15)
#define reset_color() fprintf(stderr, "\033[0m")
#endif
static int use_color=-1;
static int use_color = -1;
#undef fprintf
static void colored_fputs(int level, const char *str){
if(use_color<0){
static void colored_fputs(int level, const char *str)
{
if (use_color < 0) {
#if defined(_WIN32) && !defined(__MINGW32CE__)
CONSOLE_SCREEN_BUFFER_INFO con_info;
con = GetStdHandle(STD_ERROR_HANDLE);
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR");
use_color = (con != INVALID_HANDLE_VALUE) && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
if (use_color) {
GetConsoleScreenBufferInfo(con, &con_info);
attr_orig = con_info.wAttributes;
background = attr_orig & 0xF0;
}
#elif HAVE_ISATTY
use_color= !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
(getenv("TERM") && isatty(2) || getenv("AV_LOG_FORCE_COLOR"));
use_color = !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR") &&
(getenv("TERM") && isatty(2) ||
getenv("AV_LOG_FORCE_COLOR"));
#else
use_color= getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") && !getenv("AV_LOG_FORCE_NOCOLOR");
use_color = getenv("AV_LOG_FORCE_COLOR") && !getenv("NO_COLOR") &&
!getenv("AV_LOG_FORCE_NOCOLOR");
#endif
}
if(use_color){
if (use_color) {
set_color(level);
}
fputs(str, stderr);
if(use_color){
if (use_color) {
reset_color();
}
}
const char* av_default_item_name(void* ptr){
return (*(AVClass**)ptr)->class_name;
const char *av_default_item_name(void *ptr)
{
return (*(AVClass **) ptr)->class_name;
}
void av_log_default_callback(void* ptr, int level, const char* fmt, va_list vl)
{
static int print_prefix=1;
static int print_prefix = 1;
static int count;
static char prev[1024];
char line[1024];
static int is_atty;
AVClass* avc= ptr ? *(AVClass**)ptr : NULL;
if(level>av_log_level)
AVClass* avc = ptr ? *(AVClass **) ptr : NULL;
if (level > av_log_level)
return;
line[0]=0;
line[0] = 0;
#undef fprintf
if(print_prefix && avc) {
if (print_prefix && avc) {
if (avc->parent_log_context_offset) {
AVClass** parent= *(AVClass***)(((uint8_t*)ptr) + avc->parent_log_context_offset);
if(parent && *parent){
snprintf(line, sizeof(line), "[%s @ %p] ", (*parent)->item_name(parent), parent);
AVClass** parent = *(AVClass ***) (((uint8_t *) ptr) +
avc->parent_log_context_offset);
if (parent && *parent) {
snprintf(line, sizeof(line), "[%s @ %p] ",
(*parent)->item_name(parent), parent);
}
}
snprintf(line + strlen(line), sizeof(line) - strlen(line), "[%s @ %p] ", avc->item_name(ptr), ptr);
snprintf(line + strlen(line), sizeof(line) - strlen(line), "[%s @ %p] ",
avc->item_name(ptr), ptr);
}
vsnprintf(line + strlen(line), sizeof(line) - strlen(line), fmt, vl);
print_prefix = strlen(line) && line[strlen(line)-1] == '\n';
print_prefix = strlen(line) && line[strlen(line) - 1] == '\n';
#if HAVE_ISATTY
if(!is_atty) is_atty= isatty(2) ? 1 : -1;
if (!is_atty)
is_atty = isatty(2) ? 1 : -1;
#endif
if(print_prefix && (flags & AV_LOG_SKIP_REPEATED) && !strncmp(line, prev, sizeof line)){
if (print_prefix && (flags & AV_LOG_SKIP_REPEATED) &&
!strncmp(line, prev, sizeof line)) {
count++;
if(is_atty==1)
if (is_atty == 1)
fprintf(stderr, " Last message repeated %d times\r", count);
return;
}
if(count>0){
if (count > 0) {
fprintf(stderr, " Last message repeated %d times\n", count);
count=0;
count = 0;
}
colored_fputs(av_clip(level>>3, 0, 6), line);
colored_fputs(av_clip(level >> 3, 0, 6), line);
av_strlcpy(prev, line, sizeof line);
}
static void (*av_log_callback)(void*, int, const char*, va_list) = av_log_default_callback;
static void (*av_log_callback)(void*, int, const char*, va_list) =
av_log_default_callback;
void av_log(void* avcl, int level, const char *fmt, ...)
{
AVClass* avc= avcl ? *(AVClass**)avcl : NULL;
AVClass* avc = avcl ? *(AVClass **) avcl : NULL;
va_list vl;
va_start(vl, fmt);
if(avc && avc->version >= (50<<16 | 15<<8 | 2) && avc->log_level_offset_offset && level>=AV_LOG_FATAL)
level += *(int*)(((uint8_t*)avcl) + avc->log_level_offset_offset);
if (avc && avc->version >= (50 << 16 | 15 << 8 | 2) &&
avc->log_level_offset_offset && level >= AV_LOG_FATAL)
level += *(int *) (((uint8_t *) avcl) + avc->log_level_offset_offset);
av_vlog(avcl, level, fmt, vl);
va_end(vl);
}
@ -154,7 +166,7 @@ void av_log_set_level(int level)
void av_log_set_flags(int arg)
{
flags= arg;
flags = arg;
}
void av_log_set_callback(void (*callback)(void*, int, const char*, va_list))

28
libavutil/random_seed.c
Unescape View File

@ -40,24 +40,24 @@ static int read_random(uint32_t *dst, const char *file)
static uint32_t get_generic_seed(void)
{
clock_t last_t=0;
int bits=0;
uint64_t random=0;
clock_t last_t = 0;
int bits = 0;
uint64_t random = 0;
unsigned i;
float s=0.000000000001;
float s = 0.000000000001;
for(i=0;bits<64;i++){
clock_t t= clock();
if(last_t && fabs(t-last_t)>s || t==(clock_t)-1){
if(i<10000 && s<(1<<24)){
s+=s;
i=t=0;
}else{
random= 2*random + (i&1);
for (i = 0; bits < 64; i++) {
clock_t t = clock();
if (last_t && fabs(t - last_t) > s || t == (clock_t) -1) {
if (i < 10000 && s < (1 << 24)) {
s += s;
i = t = 0;
} else {
random = 2 * random + (i & 1);
bits++;
}
}
last_t= t;
last_t = t;
}
#ifdef AV_READ_TIME
random ^= AV_READ_TIME();
@ -65,7 +65,7 @@ static uint32_t get_generic_seed(void)
random ^= clock();
#endif
random += random>>32;
random += random >> 32;
return random;
}

110
libavutil/rational.c
Unescape View File

@ -33,75 +33,86 @@
#include "mathematics.h"
#include "rational.h"
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max){
AVRational a0={0,1}, a1={1,0};
int sign= (num<0) ^ (den<0);
int64_t gcd= av_gcd(FFABS(num), FFABS(den));
if(gcd){
num = FFABS(num)/gcd;
den = FFABS(den)/gcd;
int av_reduce(int *dst_num, int *dst_den,
int64_t num, int64_t den, int64_t max)
{
AVRational a0 = { 0, 1 }, a1 = { 1, 0 };
int sign = (num < 0) ^ (den < 0);
int64_t gcd = av_gcd(FFABS(num), FFABS(den));
if (gcd) {
num = FFABS(num) / gcd;
den = FFABS(den) / gcd;
}
if(num<=max && den<=max){
a1= (AVRational){num, den};
den=0;
if (num <= max && den <= max) {
a1 = (AVRational) { num, den };
den = 0;
}
while(den){
uint64_t x = num / den;
int64_t next_den= num - den*x;
int64_t a2n= x*a1.num + a0.num;
int64_t a2d= x*a1.den + a0.den;
while (den) {
uint64_t x = num / den;
int64_t next_den = num - den * x;
int64_t a2n = x * a1.num + a0.num;
int64_t a2d = x * a1.den + a0.den;
if(a2n > max || a2d > max){
if(a1.num) x= (max - a0.num) / a1.num;
if(a1.den) x= FFMIN(x, (max - a0.den) / a1.den);
if (a2n > max || a2d > max) {
if (a1.num) x = (max - a0.num) / a1.num;
if (a1.den) x = FFMIN(x, (max - a0.den) / a1.den);
if (den*(2*x*a1.den + a0.den) > num*a1.den)
a1 = (AVRational){x*a1.num + a0.num, x*a1.den + a0.den};
if (den * (2 * x * a1.den + a0.den) > num * a1.den)
a1 = (AVRational) { x * a1.num + a0.num, x * a1.den + a0.den };
break;
}
a0= a1;
a1= (AVRational){a2n, a2d};
num= den;
den= next_den;
a0 = a1;
a1 = (AVRational) { a2n, a2d };
num = den;
den = next_den;
}
av_assert2(av_gcd(a1.num, a1.den) <= 1U);
*dst_num = sign ? -a1.num : a1.num;
*dst_den = a1.den;
return den==0;
return den == 0;
}
AVRational av_mul_q(AVRational b, AVRational c){
av_reduce(&b.num, &b.den, b.num * (int64_t)c.num, b.den * (int64_t)c.den, INT_MAX);
AVRational av_mul_q(AVRational b, AVRational c)
{
av_reduce(&b.num, &b.den,
b.num * (int64_t) c.num,
b.den * (int64_t) c.den, INT_MAX);
return b;
}
AVRational av_div_q(AVRational b, AVRational c){
return av_mul_q(b, (AVRational){c.den, c.num});
AVRational av_div_q(AVRational b, AVRational c)
{
return av_mul_q(b, (AVRational) { c.den, c.num });
}
AVRational av_add_q(AVRational b, AVRational c){
av_reduce(&b.num, &b.den, b.num * (int64_t)c.den + c.num * (int64_t)b.den, b.den * (int64_t)c.den, INT_MAX);
AVRational av_add_q(AVRational b, AVRational c) {
av_reduce(&b.num, &b.den,
b.num * (int64_t) c.den +
c.num * (int64_t) b.den,
b.den * (int64_t) c.den, INT_MAX);
return b;
}
AVRational av_sub_q(AVRational b, AVRational c){
return av_add_q(b, (AVRational){-c.num, c.den});
AVRational av_sub_q(AVRational b, AVRational c)
{
return av_add_q(b, (AVRational) { -c.num, c.den });
}
AVRational av_d2q(double d, int max){
AVRational av_d2q(double d, int max)
{
AVRational a;
#define LOG2 0.69314718055994530941723212145817656807550013436025
int exponent;
int64_t den;
if (isnan(d))
return (AVRational){0,0};
return (AVRational) { 0,0 };
if (isinf(d))
return (AVRational){ d<0 ? -1:1, 0 };
return (AVRational) { d < 0 ? -1 : 1, 0 };
exponent = FFMAX( (int)(log(fabs(d) + 1e-20)/LOG2), 0);
den = 1LL << (61 - exponent);
av_reduce(&a.num, &a.den, (int64_t)(d * den + 0.5), den, max);
@ -127,7 +138,7 @@ int av_nearer_q(AVRational q, AVRational q1, AVRational q2)
int av_find_nearest_q_idx(AVRational q, const AVRational* q_list)
{
int i, nearest_q_idx = 0;
for(i=0; q_list[i].den; i++)
for (i = 0; q_list[i].den; i++)
if (av_nearer_q(q, q_list[i], q_list[nearest_q_idx]) > 0)
nearest_q_idx = i;
@ -138,16 +149,19 @@ int av_find_nearest_q_idx(AVRational q, const AVRational* q_list)
int main(void)
{
AVRational a,b;
for(a.num=-2; a.num<=2; a.num++){
for(a.den=-2; a.den<=2; a.den++){
for(b.num=-2; b.num<=2; b.num++){
for(b.den=-2; b.den<=2; b.den++){
int c= av_cmp_q(a,b);
double d= av_q2d(a) == av_q2d(b) ? 0 : (av_q2d(a) - av_q2d(b));
if(d>0) d=1;
else if(d<0) d=-1;
else if(d != d) d= INT_MIN;
if(c!=d) av_log(0, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num, a.den, b.num, b.den, c,d);
for (a.num = -2; a.num <= 2; a.num++) {
for (a.den = -2; a.den <= 2; a.den++) {
for (b.num = -2; b.num <= 2; b.num++) {
for (b.den = -2; b.den <= 2; b.den++) {
int c = av_cmp_q(a,b);
double d = av_q2d(a) == av_q2d(b) ?
0 : (av_q2d(a) - av_q2d(b));
if (d > 0) d = 1;
else if (d < 0) d = -1;
else if (d != d) d = INT_MIN;
if (c != d)
av_log(0, AV_LOG_ERROR, "%d/%d %d/%d, %d %f\n", a.num,
a.den, b.num, b.den, c,d);
}
}
}

196
libavutil/tree.c
Unescape View File

@ -21,22 +21,24 @@
#include "log.h"
#include "tree.h"
typedef struct AVTreeNode{
typedef struct AVTreeNode {
struct AVTreeNode *child[2];
void *elem;
int state;
}AVTreeNode;
} AVTreeNode;
const int av_tree_node_size = sizeof(AVTreeNode);
void *av_tree_find(const AVTreeNode *t, void *key, int (*cmp)(void *key, const void *b), void *next[2]){
if(t){
unsigned int v= cmp(key, t->elem);
if(v){
if(next) next[v>>31]= t->elem;
return av_tree_find(t->child[(v>>31)^1], key, cmp, next);
}else{
if(next){
void *av_tree_find(const AVTreeNode *t, void *key,
int (*cmp)(void *key, const void *b), void *next[2])
{
if (t) {
unsigned int v = cmp(key, t->elem);
if (v) {
if (next) next[v >> 31] = t->elem;
return av_tree_find(t->child[(v >> 31) ^ 1], key, cmp, next);
} else {
if (next) {
av_tree_find(t->child[0], key, cmp, next);
av_tree_find(t->child[1], key, cmp, next);
}
@ -46,41 +48,43 @@ void *av_tree_find(const AVTreeNode *t, void *key, int (*cmp)(void *key, const v
return NULL;
}
void *av_tree_insert(AVTreeNode **tp, void *key, int (*cmp)(void *key, const void *b), AVTreeNode **next){
AVTreeNode *t= *tp;
if(t){
unsigned int v= cmp(t->elem, key);
void *av_tree_insert(AVTreeNode **tp, void *key,
int (*cmp)(void *key, const void *b), AVTreeNode **next)
{
AVTreeNode *t = *tp;
if (t) {
unsigned int v = cmp(t->elem, key);
void *ret;
if(!v){
if(*next)
if (!v) {
if (*next)
return t->elem;
else if(t->child[0]||t->child[1]){
int i= !t->child[0];
else if (t->child[0] || t->child[1]) {
int i = !t->child[0];
void *next_elem[2];
av_tree_find(t->child[i], key, cmp, next_elem);
key= t->elem= next_elem[i];
v= -i;
}else{
*next= t;
*tp=NULL;
key = t->elem = next_elem[i];
v = -i;
} else {
*next = t;
*tp = NULL;
return NULL;
}
}
ret= av_tree_insert(&t->child[v>>31], key, cmp, next);
if(!ret){
int i= (v>>31) ^ !!*next;
AVTreeNode **child= &t->child[i];
t->state += 2*i - 1;
if(!(t->state&1)){
if(t->state){
ret = av_tree_insert(&t->child[v >> 31], key, cmp, next);
if (!ret) {
int i = (v >> 31) ^ !!*next;
AVTreeNode **child = &t->child[i];
t->state += 2 * i - 1;
if (!(t->state & 1)) {
if (t->state) {
/* The following code is equivalent to
if((*child)->state*2 == -t->state)
rotate(child, i^1);
rotate(tp, i);
with rotate():
static void rotate(AVTreeNode **tp, int i){
static void rotate(AVTreeNode **tp, int i) {
AVTreeNode *t= *tp;
*tp= t->child[i];
@ -92,54 +96,62 @@ void *av_tree_insert(AVTreeNode **tp, void *key, int (*cmp)(void *key, const voi
}
but such a rotate function is both bigger and slower
*/
if((*child)->state*2 == -t->state){
*tp= (*child)->child[i^1];
(*child)->child[i^1]= (*tp)->child[i];
(*tp)->child[i]= *child;
*child= (*tp)->child[i^1];
(*tp)->child[i^1]= t;
(*tp)->child[0]->state= -((*tp)->state>0);
(*tp)->child[1]->state= (*tp)->state<0 ;
(*tp)->state=0;
}else{
*tp= *child;
*child= (*child)->child[i^1];
(*tp)->child[i^1]= t;
if((*tp)->state) t->state = 0;
else t->state>>= 1;
(*tp)->state= -t->state;
if (( *child )->state * 2 == -t->state) {
*tp = (*child)->child[i ^ 1];
(*child)->child[i ^ 1] = (*tp)->child[i];
(*tp)->child[i] = *child;
*child = ( *tp )->child[i ^ 1];
(*tp)->child[i ^ 1] = t;
(*tp)->child[0]->state = -((*tp)->state > 0);
(*tp)->child[1]->state = (*tp)->state < 0;
(*tp)->state = 0;
} else {
*tp = *child;
*child = (*child)->child[i ^ 1];
(*tp)->child[i ^ 1] = t;
if ((*tp)->state) t->state = 0;
else t->state >>= 1;
(*tp)->state = -t->state;
}
}
}
if(!(*tp)->state ^ !!*next)
if (!(*tp)->state ^ !!*next)
return key;
}
return ret;
}else{
*tp= *next; *next= NULL;
if(*tp){
(*tp)->elem= key;
} else {
*tp = *next;
*next = NULL;
if (*tp) {
(*tp)->elem = key;
return NULL;
}else
} else
return key;
}
}
void av_tree_destroy(AVTreeNode *t){
if(t){
void av_tree_destroy(AVTreeNode *t)
{
if (t) {
av_tree_destroy(t->child[0]);
av_tree_destroy(t->child[1]);
av_free(t);
}
}
void av_tree_enumerate(AVTreeNode *t, void *opaque, int (*cmp)(void *opaque, void *elem), int (*enu)(void *opaque, void *elem)){
if(t){
int v= cmp ? cmp(opaque, t->elem) : 0;
if(v>=0) av_tree_enumerate(t->child[0], opaque, cmp, enu);
if(v==0) enu(opaque, t->elem);
if(v<=0) av_tree_enumerate(t->child[1], opaque, cmp, enu);
void av_tree_enumerate(AVTreeNode *t, void *opaque,
int (*cmp)(void *opaque, void *elem),
int (*enu)(void *opaque, void *elem))
{
if (t) {
int v = cmp ? cmp(opaque, t->elem) : 0;
if (v >= 0)
av_tree_enumerate(t->child[0], opaque, cmp, enu);
if (v == 0)
enu(opaque, t->elem);
if (v <= 0)
av_tree_enumerate(t->child[1], opaque, cmp, enu);
}
}
@ -147,64 +159,68 @@ void av_tree_enumerate(AVTreeNode *t, void *opaque, int (*cmp)(void *opaque, voi
#include "lfg.h"
static int check(AVTreeNode *t){
if(t){
int left= check(t->child[0]);
int right= check(t->child[1]);
static int check(AVTreeNode *t)
{
if (t) {
int left = check(t->child[0]);
int right = check(t->child[1]);
if(left>999 || right>999)
if (left>999 || right>999)
return 1000;
if(right - left != t->state)
if (right - left != t->state)
return 1000;
if(t->state>1 || t->state<-1)
if (t->state>1 || t->state<-1)
return 1000;
return FFMAX(left, right)+1;
return FFMAX(left, right) + 1;
}
return 0;
}
static void print(AVTreeNode *t, int depth){
static void print(AVTreeNode *t, int depth)
{
int i;
for(i=0; i<depth*4; i++) av_log(NULL, AV_LOG_ERROR, " ");
if(t){
for (i = 0; i < depth * 4; i++) av_log(NULL, AV_LOG_ERROR, " ");
if (t) {
av_log(NULL, AV_LOG_ERROR, "Node %p %2d %p\n", t, t->state, t->elem);
print(t->child[0], depth+1);
print(t->child[1], depth+1);
}else
print(t->child[0], depth + 1);
print(t->child[1], depth + 1);
} else
av_log(NULL, AV_LOG_ERROR, "NULL\n");
}
static int cmp(void *a, const void *b){
return (uint8_t*)a-(const uint8_t*)b;
static int cmp(void *a, const void *b)
{
return (uint8_t *) a - (const uint8_t *) b;
}
int main(void){
int main (void)
{
int i;
void *k;
AVTreeNode *root= NULL, *node=NULL;
AVTreeNode *root = NULL, *node = NULL;
AVLFG prng;
av_lfg_init(&prng, 1);
for(i=0; i<10000; i++){
for (i = 0; i < 10000; i++) {
int j = av_lfg_get(&prng) % 86294;
if(check(root) > 999){
if (check(root) > 999) {
av_log(NULL, AV_LOG_ERROR, "FATAL error %d\n", i);
print(root, 0);
return -1;
}
av_log(NULL, AV_LOG_ERROR, "inserting %4d\n", j);
if(!node)
node= av_mallocz(av_tree_node_size);
av_tree_insert(&root, (void*)(j+1), cmp, &node);
if (!node)
node = av_mallocz(av_tree_node_size);
av_tree_insert(&root, (void *) (j + 1), cmp, &node);
j = av_lfg_get(&prng) % 86294;
{
AVTreeNode *node2=NULL;
AVTreeNode *node2 = NULL;
av_log(NULL, AV_LOG_ERROR, "removing %4d\n", j);
av_tree_insert(&root, (void*)(j+1), cmp, &node2);
k= av_tree_find(root, (void*)(j+1), cmp, NULL);
if(k)
av_tree_insert(&root, (void *) (j + 1), cmp, &node2);
k = av_tree_find(root, (void *) (j + 1), cmp, NULL);
if (k)
av_log(NULL, AV_LOG_ERROR, "removal failure %d\n", i);
}
}

Write Preview
Loading…
Cancel
Save