virtualenv/FFmpeg
1
0
Fork 0
mirror of https://github.com/FFmpeg/FFmpeg.git synced 2024-12-23 12:43:46 +02:00
Code Issues Releases Activity

Merge commit '90558e848a29ef1e85ecb1832ad9a26eebe958e0'

Browse Source 
* commit '90558e848a29ef1e85ecb1832ad9a26eebe958e0':
  rangecoder: K&R formatting cosmetics

Conflicts:
	libavcodec/rangecoder.c
	libavcodec/rangecoder.h

Merged-by: Michael Niedermayer <michaelni@gmx.at>
This commit is contained in:
Michael Niedermayer 2012-10-13 15:35:05 +02:00
commit c55bebe2cc
2 changed files with 103 additions and 95 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

106
libavcodec/rangecoder.c
View File

@ -38,70 +38,72 @@
#include "rangecoder.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 */
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((const uint8_t **)&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;
int last_p8, p8, i;
memset(c->zero_state, 0, sizeof(c->zero_state));
memset(c-> one_state, 0, sizeof(c-> one_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;
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;
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;
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);
c->range=0xFF;
c->range = 0xFF;
renorm_encoder(c);
av_assert1(c->low == 0);
@ -115,10 +117,11 @@ int ff_rac_terminate(RangeCoder *c){
#include "libavutil/lfg.h"
int main(void){
int main(void)
{
RangeCoder c;
uint8_t b[9*SIZE];
uint8_t r[9*SIZE];
uint8_t b[9 * SIZE];
uint8_t r[9 * SIZE];
int i;
uint8_t state[10];
AVLFG prng;
@ -126,17 +129,16 @@ int main(void){
av_lfg_init(&prng, 1);
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));
for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++)
r[i] = av_lfg_get(&prng) % 7;
}
for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++) {
START_TIMER
put_rac(&c, state, r[i]&1);
put_rac(&c, state, r[i] & 1);
STOP_TIMER("put_rac")
}
@ -146,9 +148,9 @@ STOP_TIMER("put_rac")
memset(state, 128, sizeof(state));
for(i=0; i<SIZE; i++){
for (i = 0; i < SIZE; i++) {
START_TIMER
if( (r[i]&1) != get_rac(&c, state) )
if ((r[i] & 1) != get_rac(&c, state))
av_log(NULL, AV_LOG_ERROR, "rac failure at %d\n", i);
STOP_TIMER("get_rac")
}

92
libavcodec/rangecoder.h
View File

@ -28,113 +28,119 @@
#define AVCODEC_RANGECODER_H
#include <stdint.h>
#include "libavutil/common.h"
#include "libavutil/avassert.h"
typedef struct RangeCoder{
typedef struct RangeCoder {
int low;
int range;
int outstanding_count;
int outstanding_byte;
uint8_t zero_state[256];
uint8_t one_state[256];
uint8_t one_state[256];
uint8_t *bytestream_start;
uint8_t *bytestream;
uint8_t *bytestream_end;
}RangeCoder;
} RangeCoder;
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);
int ff_rac_terminate(RangeCoder *c);
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;
for(;c->outstanding_count; c->outstanding_count--)
for (; c->outstanding_count; c->outstanding_count--)
*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;
for(;c->outstanding_count; c->outstanding_count--)
for (; c->outstanding_count; c->outstanding_count--)
*c->bytestream++ = 0x00;
c->outstanding_byte= (c->low>>8) & 0xFF;
}else{
c->outstanding_byte = (c->low >> 8) & 0xFF;
} else {
c->outstanding_count++;
}
c->low = (c->low & 0xFF)<<8;
c->low = (c->low & 0xFF) << 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++;
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;
av_assert2(*state);
av_assert2(range1 < c->range);
av_assert2(range1 > 0);
if(!bit){
if (!bit) {
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;
*state= c->one_state[*state];
*state = c->one_state[*state];
}
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->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++;
}
}
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;
c->range -= range1;
#if 1
if(c->low < c->range){
*state= c->zero_state[*state];
if (c->low < c->range) {
*state = c->zero_state[*state];
refill(c);
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;
refill(c);
return 1;
}
#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;
*state= c->zero_state[(*state) + (256&one_mask)];
*state = c->zero_state[(*state) + (256 & one_mask)];
refill(c);
return one_mask&1;
return one_mask & 1;
#endif
}