falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

rangecoder: K&R formatting cosmetics

tags/n1.1
Diego Biurrun 13 years ago
parent
ca411fc1d3
commit
90558e848a
2 changed files with 106 additions and 98 deletions
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +57
    -55
      libavcodec/rangecoder.c
  2. +49
    -43
      libavcodec/rangecoder.h

+ 57
- 55
libavcodec/rangecoder.c View File

@@ -37,73 +37,75 @@
#include "rangecoder.h" #include "rangecoder.h"
#include "bytestream.h" #include "bytestream.h"



void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size){
c->bytestream_start=
c->bytestream= buf;
c->bytestream_end= buf + buf_size;

c->low= 0;
c->range= 0xFF00;
c->outstanding_count= 0;
c->outstanding_byte= -1;
void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size)
{
c->bytestream_start =
c->bytestream = buf;
c->bytestream_end = buf + buf_size;
c->low = 0;
c->range = 0xFF00;
c->outstanding_count = 0;
c->outstanding_byte = -1;
} }


void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size){
void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size)
{
/* cast to avoid compiler warning */ /* cast to avoid compiler warning */
ff_init_range_encoder(c, (uint8_t *) buf, buf_size);
ff_init_range_encoder(c, (uint8_t *)buf, buf_size);


c->low = bytestream_get_be16(&c->bytestream); c->low = bytestream_get_be16(&c->bytestream);
} }


void ff_build_rac_states(RangeCoder *c, int factor, int max_p){
const int64_t one= 1LL<<32;
void ff_build_rac_states(RangeCoder *c, int factor, int max_p)
{
const int64_t one = 1LL << 32;
int64_t p; int64_t p;
int last_p8, p8, i; int last_p8, p8, i;


memset(c->zero_state, 0, sizeof(c->zero_state)); memset(c->zero_state, 0, sizeof(c->zero_state));
memset(c-> one_state, 0, sizeof(c-> one_state));

last_p8= 0;
p= one/2;
for(i=0; i<128; i++){
p8= (256*p + one/2) >> 32; //FIXME try without the one
if(p8 <= last_p8) p8= last_p8+1;
if(last_p8 && last_p8<256 && p8<=max_p)
c->one_state[last_p8]= p8;

p+= ((one-p)*factor + one/2) >> 32;
last_p8= p8;
memset(c->one_state, 0, sizeof(c->one_state));

last_p8 = 0;
p = one / 2;
for (i = 0; i < 128; i++) {
p8 = (256 * p + one / 2) >> 32; // FIXME: try without the one
if (p8 <= last_p8)
p8 = last_p8 + 1;
if (last_p8 && last_p8 < 256 && p8 <= max_p)
c->one_state[last_p8] = p8;

p += ((one - p) * factor + one / 2) >> 32;
last_p8 = p8;
} }


for(i=256-max_p; i<=max_p; i++){
if(c->one_state[i])
for (i = 256 - max_p; i <= max_p; i++) {
if (c->one_state[i])
continue; continue;


p= (i*one + 128) >> 8;
p+= ((one-p)*factor + one/2) >> 32;
p8= (256*p + one/2) >> 32; //FIXME try without the one
if(p8 <= i) p8= i+1;
if(p8 > max_p) p8= max_p;
c->one_state[ i]= p8;
p = (i * one + 128) >> 8;
p += ((one - p) * factor + one / 2) >> 32;
p8 = (256 * p + one / 2) >> 32; // FIXME: try without the one
if (p8 <= i)
p8 = i + 1;
if (p8 > max_p)
p8 = max_p;
c->one_state[i] = p8;
} }


for(i=1; i<255; i++)
c->zero_state[i]= 256-c->one_state[256-i];
for (i = 1; i < 255; i++)
c->zero_state[i] = 256 - c->one_state[256 - i];
} }


/**
*
* @return the number of bytes written
*/
int ff_rac_terminate(RangeCoder *c){
c->range=0xFF;
c->low +=0xFF;
/* Return the number of bytes written. */
int ff_rac_terminate(RangeCoder *c)
{
c->range = 0xFF;
c->low += 0xFF;
renorm_encoder(c); renorm_encoder(c);
c->range=0xFF;
c->range = 0xFF;
renorm_encoder(c); renorm_encoder(c);


assert(c->low == 0);
assert(c->low == 0);
assert(c->range >= 0x100); assert(c->range >= 0x100);


return c->bytestream - c->bytestream_start; return c->bytestream - c->bytestream_start;
@@ -114,10 +116,11 @@ int ff_rac_terminate(RangeCoder *c){


#include "libavutil/lfg.h" #include "libavutil/lfg.h"


int main(void){
int main(void)
{
RangeCoder c; RangeCoder c;
uint8_t b[9*SIZE];
uint8_t r[9*SIZE];
uint8_t b[9 * SIZE];
uint8_t r[9 * SIZE];
int i; int i;
uint8_t state[10]; uint8_t state[10];
AVLFG prng; AVLFG prng;
@@ -125,17 +128,16 @@ int main(void){
av_lfg_init(&prng, 1); av_lfg_init(&prng, 1);


ff_init_range_encoder(&c, b, SIZE); ff_init_range_encoder(&c, b, SIZE);
ff_build_rac_states(&c, 0.05*(1LL<<32), 128+64+32+16);
ff_build_rac_states(&c, 0.05 * (1LL << 32), 128 + 64 + 32 + 16);


memset(state, 128, sizeof(state)); memset(state, 128, sizeof(state));


for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++)
r[i] = av_lfg_get(&prng) % 7; r[i] = av_lfg_get(&prng) % 7;
}


for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++) {
START_TIMER START_TIMER
put_rac(&c, state, r[i]&1);
put_rac(&c, state, r[i] & 1);
STOP_TIMER("put_rac") STOP_TIMER("put_rac")
} }


@@ -145,9 +147,9 @@ STOP_TIMER("put_rac")


memset(state, 128, sizeof(state)); memset(state, 128, sizeof(state));


for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++) {
START_TIMER START_TIMER
if( (r[i]&1) != get_rac(&c, state) )
if ((r[i] & 1) != get_rac(&c, state))
av_log(NULL, AV_LOG_DEBUG, "rac failure at %d\n", i); av_log(NULL, AV_LOG_DEBUG, "rac failure at %d\n", i);
STOP_TIMER("get_rac") STOP_TIMER("get_rac")
} }


+ 49
- 43
libavcodec/rangecoder.h View File

@@ -29,112 +29,118 @@


#include <stdint.h> #include <stdint.h>
#include <assert.h> #include <assert.h>

#include "libavutil/common.h" #include "libavutil/common.h"


typedef struct RangeCoder{
typedef struct RangeCoder {
int low; int low;
int range; int range;
int outstanding_count; int outstanding_count;
int outstanding_byte; int outstanding_byte;
uint8_t zero_state[256]; uint8_t zero_state[256];
uint8_t one_state[256];
uint8_t one_state[256];
uint8_t *bytestream_start; uint8_t *bytestream_start;
uint8_t *bytestream; uint8_t *bytestream;
uint8_t *bytestream_end; uint8_t *bytestream_end;
}RangeCoder;
} RangeCoder;


void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size); void ff_init_range_encoder(RangeCoder *c, uint8_t *buf, int buf_size);
void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size); void ff_init_range_decoder(RangeCoder *c, const uint8_t *buf, int buf_size);
int ff_rac_terminate(RangeCoder *c); int ff_rac_terminate(RangeCoder *c);
void ff_build_rac_states(RangeCoder *c, int factor, int max_p); void ff_build_rac_states(RangeCoder *c, int factor, int max_p);


static inline void renorm_encoder(RangeCoder *c){
//FIXME optimize
while(c->range < 0x100){
if(c->outstanding_byte < 0){
c->outstanding_byte= c->low>>8;
}else if(c->low <= 0xFF00){
static inline void renorm_encoder(RangeCoder *c)
{
// FIXME: optimize
while (c->range < 0x100) {
if (c->outstanding_byte < 0) {
c->outstanding_byte = c->low >> 8;
} else if (c->low <= 0xFF00) {
*c->bytestream++ = c->outstanding_byte; *c->bytestream++ = c->outstanding_byte;
for(;c->outstanding_count; c->outstanding_count--)
for (; c->outstanding_count; c->outstanding_count--)
*c->bytestream++ = 0xFF; *c->bytestream++ = 0xFF;
c->outstanding_byte= c->low>>8;
}else if(c->low >= 0x10000){
c->outstanding_byte = c->low >> 8;
} else if (c->low >= 0x10000) {
*c->bytestream++ = c->outstanding_byte + 1; *c->bytestream++ = c->outstanding_byte + 1;
for(;c->outstanding_count; c->outstanding_count--)
for (; c->outstanding_count; c->outstanding_count--)
*c->bytestream++ = 0x00; *c->bytestream++ = 0x00;
c->outstanding_byte= (c->low>>8) & 0xFF;
}else{
c->outstanding_byte = (c->low >> 8) & 0xFF;
} else {
c->outstanding_count++; c->outstanding_count++;
} }


c->low = (c->low & 0xFF)<<8;
c->low = (c->low & 0xFF) << 8;
c->range <<= 8; c->range <<= 8;
} }
} }


static inline int get_rac_count(RangeCoder *c){
int x= c->bytestream - c->bytestream_start + c->outstanding_count;
if(c->outstanding_byte >= 0)
static inline int get_rac_count(RangeCoder *c)
{
int x = c->bytestream - c->bytestream_start + c->outstanding_count;
if (c->outstanding_byte >= 0)
x++; x++;
return 8*x - av_log2(c->range);
return 8 * x - av_log2(c->range);
} }


static inline void put_rac(RangeCoder *c, uint8_t * const state, int bit){
int range1= (c->range * (*state)) >> 8;
static inline void put_rac(RangeCoder *c, uint8_t *const state, int bit)
{
int range1 = (c->range * (*state)) >> 8;


assert(*state); assert(*state);
assert(range1 < c->range); assert(range1 < c->range);
assert(range1 > 0); assert(range1 > 0);
if(!bit){
if (!bit) {
c->range -= range1; c->range -= range1;
*state= c->zero_state[*state];
}else{
c->low += c->range - range1;
*state = c->zero_state[*state];
} else {
c->low += c->range - range1;
c->range = range1; c->range = range1;
*state= c->one_state[*state];
*state = c->one_state[*state];
} }


renorm_encoder(c); renorm_encoder(c);
} }


static inline void refill(RangeCoder *c){
if(c->range < 0x100){
static inline void refill(RangeCoder *c)
{
if (c->range < 0x100) {
c->range <<= 8; c->range <<= 8;
c->low <<= 8;
if(c->bytestream < c->bytestream_end)
c->low+= c->bytestream[0];
c->low <<= 8;
if (c->bytestream < c->bytestream_end)
c->low += c->bytestream[0];
c->bytestream++; c->bytestream++;
} }
} }


static inline int get_rac(RangeCoder *c, uint8_t * const state){
int range1= (c->range * (*state)) >> 8;
static inline int get_rac(RangeCoder *c, uint8_t *const state)
{
int range1 = (c->range * (*state)) >> 8;
int av_unused one_mask; int av_unused one_mask;


c->range -= range1; c->range -= range1;
#if 1 #if 1
if(c->low < c->range){
*state= c->zero_state[*state];
if (c->low < c->range) {
*state = c->zero_state[*state];
refill(c); refill(c);
return 0; return 0;
}else{
c->low -= c->range;
*state= c->one_state[*state];
} else {
c->low -= c->range;
*state = c->one_state[*state];
c->range = range1; c->range = range1;
refill(c); refill(c);
return 1; return 1;
} }
#else #else
one_mask= (c->range - c->low-1)>>31;
one_mask = (c->range - c->low - 1) >> 31;


c->low -= c->range & one_mask;
c->low -= c->range & one_mask;
c->range += (range1 - c->range) & one_mask; c->range += (range1 - c->range) & one_mask;


*state= c->zero_state[(*state) + (256&one_mask)];
*state = c->zero_state[(*state) + (256 & one_mask)];


refill(c); refill(c);


return one_mask&1;
return one_mask & 1;
#endif #endif
} }




Write Preview
Loading…
Cancel
Save