util.c

来自「这个库实现了录象功能」· C语言 代码 · 共 941 行 · 第 1/2 页

        if (negative)
                out [0] |= 0x80 ;

        if (exponent & 0x01)
                out [1] |= 0x80 ;

        out [3] = mantissa & 0xFF ;
        out [2] = (mantissa >> 8) & 0xFF ;
        out [1] |= (mantissa >> 16) & 0x7F ;
        out [0] |= (exponent >> 1) & 0x7F ;

        return ;
} /* float32_be_write */


static void
double64_be_write (double in, unsigned char *out)
{       int             exponent, mantissa ;

        memset (out, 0, sizeof (double)) ;

        if (in == 0.0)
                return ;

        if (in < 0.0)
        {       in *= -1.0 ;
                out [0] |= 0x80 ;
                } ;

        in = frexp (in, &exponent) ;

        exponent += 1022 ;

        out [0] |= (exponent >> 4) & 0x7F ;
        out [1] |= (exponent << 4) & 0xF0 ;

        in *= 0x20000000 ;
        mantissa = lrint (floor (in)) ;

        out [1] |= (mantissa >> 24) & 0xF ;
        out [2] = (mantissa >> 16) & 0xFF ;
        out [3] = (mantissa >> 8) & 0xFF ;
        out [4] = mantissa & 0xFF ;

        in = fmod (in, 1.0) ;
        in *= 0x1000000 ;
        mantissa = lrint (floor (in)) ;

        out [5] = (mantissa >> 16) & 0xFF ;
        out [6] = (mantissa >> 8) & 0xFF ;
        out [7] = mantissa & 0xFF ;

        return ;
} /* double64_be_write */


float quicktime_read_float32(quicktime_t *file)
  {
  unsigned char b[4];
  quicktime_read_data(file, b, 4);
  return float32_be_read(b);
  }

double quicktime_read_double64(quicktime_t *file)
  {
  unsigned char b[8];
  quicktime_read_data(file, b, 8);
  return double64_be_read(b);
  }


int quicktime_write_float32(quicktime_t *file, float value)
  {
  unsigned char b[4];
  float32_be_write(value, b);
  return quicktime_write_data(file, b, 4);
  }

int quicktime_write_double64(quicktime_t *file, double value)
  {
  unsigned char b[8];
  double64_be_write(value, b);
  return quicktime_write_data(file, b, 8);
  }

int quicktime_write_int64(quicktime_t *file, int64_t value)
{
	unsigned char data[8];

	data[0] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
	data[1] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
	data[2] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
	data[3] = (((uint64_t)value) & 0xff00000000LL) >> 32;
	data[4] = (((uint64_t)value) & 0xff000000LL) >> 24;
	data[5] = (((uint64_t)value) & 0xff0000LL) >> 16;
	data[6] = (((uint64_t)value) & 0xff00LL) >> 8;
	data[7] =  ((uint64_t)value) & 0xff;

	return quicktime_write_data(file, data, 8);
}

int quicktime_write_int64_le(quicktime_t *file, int64_t value)
{
        unsigned char data[8];
 
        data[7] = (((uint64_t)value) & 0xff00000000000000LL) >> 56;
        data[6] = (((uint64_t)value) & 0xff000000000000LL) >> 48;
        data[5] = (((uint64_t)value) & 0xff0000000000LL) >> 40;
        data[4] = (((uint64_t)value) & 0xff00000000LL) >> 32;
        data[3] = (((uint64_t)value) & 0xff000000LL) >> 24;
        data[2] = (((uint64_t)value) & 0xff0000LL) >> 16;
        data[1] = (((uint64_t)value) & 0xff00LL) >> 8;
        data[0] =  ((uint64_t)value) & 0xff;
                                                                                                                  
        return quicktime_write_data(file, data, 8);
}


int quicktime_write_int32(quicktime_t *file, long value)
{
	unsigned char data[4];

	data[0] = (value & 0xff000000) >> 24;
	data[1] = (value & 0xff0000) >> 16;
	data[2] = (value & 0xff00) >> 8;
	data[3] = value & 0xff;

	return quicktime_write_data(file, data, 4);
}

int quicktime_write_int32_le(quicktime_t *file, long value)
{
	unsigned char data[4];

	data[3] = (value & 0xff000000) >> 24;
	data[2] = (value & 0xff0000) >> 16;
	data[1] = (value & 0xff00) >> 8;
	data[0] = value & 0xff;

	return quicktime_write_data(file, data, 4);
}

int quicktime_write_char32(quicktime_t *file, char *string)
{
return quicktime_write_data(file, (uint8_t*)string, 4);
}


float quicktime_read_fixed16(quicktime_t *file)
{
	unsigned char data[2];
	
	quicktime_read_data(file, data, 2);
	if(data[1])
		return (float)data[0] + (float)data[1] / 256;
	else
		return (float)data[0];
}

int quicktime_write_fixed16(quicktime_t *file, float number)
{
	unsigned char data[2];
	int a, b;

	a = number;
	b = (number - a) * 256;
	data[0] = a;
	data[1] = b;

	return quicktime_write_data(file, data, 2);
}

unsigned long quicktime_read_uint32(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b, c, d;
	uint8_t data[4];

	quicktime_read_data(file, data, 4);
	a = data[0];
	b = data[1];
	c = data[2];
	d = data[3];

	result = (a << 24) | (b << 16) | (c << 8) | d;
	return result;
}

long quicktime_read_int32(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b, c, d;
	uint8_t data[4];

	quicktime_read_data(file, data, 4);
	a = data[0];
	b = data[1];
	c = data[2];
	d = data[3];

	result = (a << 24) | (b << 16) | (c << 8) | d;
	return (long)result;
}

long quicktime_read_int32_le(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b, c, d;
	uint8_t data[4];

	quicktime_read_data(file, data, 4);
	a = data[0];
	b = data[1];
	c = data[2];
	d = data[3];

	result = (d << 24) | (c << 16) | (b << 8) | a;
	return (long)result;
}

int64_t quicktime_read_int64(quicktime_t *file)
{
	uint64_t result, a, b, c, d, e, f, g, h;
	uint8_t data[8];

	quicktime_read_data(file, data, 8);
	a = data[0];
	b = data[1];
	c = data[2];
	d = data[3];
	e = data[4];
	f = data[5];
	g = data[6];
	h = data[7];

	result = (a << 56) | 
		(b << 48) | 
		(c << 40) | 
		(d << 32) | 
		(e << 24) | 
		(f << 16) | 
		(g << 8) | 
		h;
	return (int64_t)result;
}


int64_t quicktime_read_int64_le(quicktime_t *file)
{
        uint64_t result, a, b, c, d, e, f, g, h;
        uint8_t data[8];
                                                                                                                  
        quicktime_read_data(file, data, 8);
        a = data[7];
        b = data[6];
        c = data[5];
        d = data[4];
        e = data[3];
        f = data[2];
        g = data[1];
        h = data[0];
                                                                                                                  
        result = (a << 56) |
                (b << 48) |
                (c << 40) |
                (d << 32) |
                (e << 24) |
                (f << 16) |
                (g << 8) |
                h;
        return (int64_t)result;
}


long quicktime_read_int24(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b, c;
        uint8_t data[4];
	
	quicktime_read_data(file, data, 3);
	a = data[0];
	b = data[1];
	c = data[2];

	result = (a << 16) | (b << 8) | c;
	return (long)result;
}

int quicktime_write_int24(quicktime_t *file, long number)
{
	unsigned char data[3];
	data[0] = (number & 0xff0000) >> 16;
	data[1] = (number & 0xff00) >> 8;
	data[2] = (number & 0xff);
	
	return quicktime_write_data(file, data, 3);
}

int quicktime_read_int16(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b;
        uint8_t data[2];
	
	quicktime_read_data(file, data, 2);
	a = data[0];
	b = data[1];

	result = (a << 8) | b;
	return (int)result;
}

int quicktime_read_int16_le(quicktime_t *file)
{
	unsigned long result;
	unsigned long a, b;
	uint8_t data[2];
	
	quicktime_read_data(file, data, 2);
	a = data[0];
	b = data[1];

	result = (b << 8) | a;
	return (int)result;
}

int quicktime_write_int16(quicktime_t *file, int number)
{
	unsigned char data[2];
	data[0] = (number & 0xff00) >> 8;
	data[1] = (number & 0xff);
	
	return quicktime_write_data(file, data, 2);
}

int quicktime_write_int16_le(quicktime_t *file, int number)
{
	unsigned char data[2];
	data[1] = (number & 0xff00) >> 8;
	data[0] = (number & 0xff);
	
	return quicktime_write_data(file, data, 2);
}

int quicktime_read_char(quicktime_t *file)
{
	char output;
	quicktime_read_data(file, (uint8_t*)(&output), 1);
	return output;
}

int quicktime_write_char(quicktime_t *file, char x)
{
return quicktime_write_data(file, (uint8_t*)(&x), 1);
}

void quicktime_read_char32(quicktime_t *file, char *string)
{
quicktime_read_data(file, (uint8_t*)string, 4);
}

int64_t quicktime_position(quicktime_t *file) 
{ 
	return file->file_position; 
}

int quicktime_set_position(quicktime_t *file, int64_t position) 
{
	file->file_position = position;
	return 0;
}

void quicktime_copy_char32(char *output, char *input)
{
	*output++ = *input++;
	*output++ = *input++;
	*output++ = *input++;
	*output = *input;
}


void quicktime_print_chars(char *desc, uint8_t *input, int len)
{
	int i;
	lqt_dump("%s", desc);
	for(i = 0; i < len; i++) lqt_dump("%02x ", input[i]);
	lqt_dump("\n");
}

unsigned long quicktime_current_time(void)
{
	time_t t;
	time (&t);
	return (t+(66*31536000)+1468800);
}

int quicktime_match_32(void *_input, void *_output)
{
        uint8_t * input = (uint8_t*)_input;
        uint8_t * output = (uint8_t*)_output;
	if(input[0] == output[0] &&
		input[1] == output[1] &&
		input[2] == output[2] &&
		input[3] == output[3])
		return 1;
	else 
		return 0;
}

int quicktime_match_24(char *input, char *output)
{
	if(input[0] == output[0] &&
		input[1] == output[1] &&
		input[2] == output[2])
		return 1;
	else 
		return 0;
}

static void do_hexdump(uint8_t * data, int len, int linebreak, FILE * f)
  {
  int i;
  int bytes_written = 0;
  int imax;

  while(bytes_written < len)
    {
    imax = (bytes_written + linebreak > len) ? len - bytes_written : linebreak;
    for(i = 0; i < imax; i++)
      fprintf(f, "%02x ", data[bytes_written + i]);
    for(i = imax; i < linebreak; i++)
      fprintf(f, "   ");
    for(i = 0; i < imax; i++)
      {
      if(!(data[bytes_written + i] & 0x80) && (data[bytes_written + i] >= 32))
        fprintf(f, "%c", data[bytes_written + i]);
      else
        fprintf(f, ".");
      }
    bytes_written += imax;
    fprintf(f, "\n");
    }
  }

void lqt_hexdump(uint8_t * data, int len, int linebreak)
  {
  do_hexdump(data, len, linebreak, stderr);  
  }

void lqt_hexdump_stdout(uint8_t * data, int len, int linebreak)
  {
  do_hexdump(data, len, linebreak, stdout);  
  }

void lqt_dump_time(uint64_t t)
  {
  time_t ti;
  struct tm tm;
  /*  2082844800 = seconds between 1/1/04 and 1/1/70 */
  ti = t - 2082844800;
  localtime_r(&ti, &tm);
  tm.tm_mon++;
  tm.tm_mday++;
  printf("%04d-%02d-%02d %02d:%02d:%02d (%"PRId64")",
         tm.tm_year+1900, tm.tm_mon, tm.tm_mday,
         tm.tm_hour, tm.tm_min, tm.tm_sec, t);
  }