rangecoder: K&R formatting cosmetics

libavcodec/rangecoder.c

@@ -37,70 +37,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(&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));
-
-    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;
 
-        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);
 
     assert(c->low == 0);
@@ -114,10 +116,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;
@@ -125,17 +128,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")
     }
 
@@ -145,9 +147,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_DEBUG, "rac failure at %d\n", i);
 STOP_TIMER("get_rac")
     }

libavcodec/rangecoder.h

@@ -29,9 +29,10 @@
 
 #include <stdint.h>
 #include <assert.h>
+
 #include "libavutil/common.h"
 
-typedef struct RangeCoder{
+typedef struct RangeCoder {
     int low;
     int range;
     int outstanding_count;
@@ -41,100 +42,105 @@ typedef struct RangeCoder{
     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;
 
     assert(*state);
     assert(range1 < c->range);
     assert(range1 > 0);
-    if(!bit){
+    if (!bit) {
         c->range -= range1;
-        *state= c->zero_state[*state];
-    }else{
+        *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];
+        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{
+    } else {
         c->low  -= c->range;
-        *state= c->one_state[*state];
+        *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->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
 }