cosmetics: K&R coding style and more whitespace for Flash Screen Video

libavcodec/flashsv.c

@@ -49,32 +49,30 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <zlib.h>
 
 #include "avcodec.h"
 #include "get_bits.h"
 
-#include <zlib.h>
-
 typedef struct FlashSVContext {
     AVCodecContext *avctx;
-    AVFrame frame;
-    int image_width, image_height;
-    int block_width, block_height;
-    uint8_t* tmpblock;
-    int block_size;
-    z_stream zstream;
+    AVFrame         frame;
+    int             image_width, image_height;
+    int             block_width, block_height;
+    uint8_t        *tmpblock;
+    int             block_size;
+    z_stream        zstream;
 } FlashSVContext;
 
 
 static void copy_region(uint8_t *sptr, uint8_t *dptr,
-        int dx, int dy, int h, int w, int stride)
+                        int dx, int dy, int h, int w, int stride)
 {
     int i;
 
-    for (i = dx+h; i > dx; i--)
-    {
-        memcpy(dptr+(i*stride)+dy*3, sptr, w*3);
-        sptr += w*3;
+    for (i = dx + h; i > dx; i--) {
+        memcpy(dptr + (i * stride) + dy * 3, sptr, w * 3);
+        sptr += w * 3;
     }
 }
 
@@ -84,9 +82,9 @@ static av_cold int flashsv_decode_init(AVCodecContext *avctx)
     FlashSVContext *s = avctx->priv_data;
     int zret; // Zlib return code
 
-    s->avctx = avctx;
+    s->avctx          = avctx;
     s->zstream.zalloc = Z_NULL;
-    s->zstream.zfree = Z_NULL;
+    s->zstream.zfree  = Z_NULL;
     s->zstream.opaque = Z_NULL;
     zret = inflateInit(&(s->zstream));
     if (zret != Z_OK) {
@@ -100,13 +98,12 @@ static av_cold int flashsv_decode_init(AVCodecContext *avctx)
 }
 
 
-static int flashsv_decode_frame(AVCodecContext *avctx,
-                                    void *data, int *data_size,
-                                    AVPacket *avpkt)
+static int flashsv_decode_frame(AVCodecContext *avctx, void *data,
+                                int *data_size, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
-    int buf_size = avpkt->size;
-    FlashSVContext *s = avctx->priv_data;
+    int buf_size       = avpkt->size;
+    FlashSVContext *s  = avctx->priv_data;
     int h_blocks, v_blocks, h_part, v_part, i, j;
     GetBitContext gb;
 
@@ -119,66 +116,64 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
     init_get_bits(&gb, buf, buf_size * 8);
 
     /* start to parse the bitstream */
-    s->block_width = 16* (get_bits(&gb, 4)+1);
-    s->image_width =     get_bits(&gb,12);
-    s->block_height= 16* (get_bits(&gb, 4)+1);
-    s->image_height=     get_bits(&gb,12);
+    s->block_width  = 16 * (get_bits(&gb,  4) + 1);
+    s->image_width  =       get_bits(&gb, 12);
+    s->block_height = 16 * (get_bits(&gb,  4) + 1);
+    s->image_height =       get_bits(&gb, 12);
 
     /* calculate amount of blocks and the size of the border blocks */
-    h_blocks = s->image_width / s->block_width;
-    h_part = s->image_width % s->block_width;
+    h_blocks = s->image_width  / s->block_width;
+    h_part   = s->image_width  % s->block_width;
     v_blocks = s->image_height / s->block_height;
-    v_part = s->image_height % s->block_height;
+    v_part   = s->image_height % s->block_height;
 
     /* the block size could change between frames, make sure the buffer
      * is large enough, if not, get a larger one */
-    if(s->block_size < s->block_width*s->block_height) {
+    if (s->block_size < s->block_width * s->block_height) {
         av_free(s->tmpblock);
-        if ((s->tmpblock = av_malloc(3*s->block_width*s->block_height)) == NULL) {
+        if ((s->tmpblock = av_malloc(3 * s->block_width * s->block_height)) == NULL) {
             av_log(avctx, AV_LOG_ERROR, "Can't allocate decompression buffer.\n");
             return -1;
         }
     }
-    s->block_size = s->block_width*s->block_height;
+    s->block_size = s->block_width * s->block_height;
 
     /* init the image size once */
-    if((avctx->width==0) && (avctx->height==0)){
-        avctx->width = s->image_width;
+    if ((avctx->width == 0) && (avctx->height == 0)) {
+        avctx->width  = s->image_width;
         avctx->height = s->image_height;
     }
 
     /* check for changes of image width and image height */
     if ((avctx->width != s->image_width) || (avctx->height != s->image_height)) {
         av_log(avctx, AV_LOG_ERROR, "Frame width or height differs from first frames!\n");
-        av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n",avctx->height,
-        avctx->width,s->image_height,s->image_width);
+        av_log(avctx, AV_LOG_ERROR, "fh = %d, fv %d  vs  ch = %d, cv = %d\n", avctx->height,
+        avctx->width,s->image_height, s->image_width);
         return -1;
     }
 
     av_log(avctx, AV_LOG_DEBUG, "image: %dx%d block: %dx%d num: %dx%d part: %dx%d\n",
-        s->image_width, s->image_height, s->block_width, s->block_height,
-        h_blocks, v_blocks, h_part, v_part);
+           s->image_width, s->image_height, s->block_width, s->block_height,
+           h_blocks, v_blocks, h_part, v_part);
 
-    s->frame.reference = 1;
+    s->frame.reference    = 1;
     s->frame.buffer_hints = FF_BUFFER_HINTS_VALID | FF_BUFFER_HINTS_PRESERVE | FF_BUFFER_HINTS_REUSABLE;
-    if(avctx->reget_buffer(avctx, &s->frame) < 0){
-      av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
-      return -1;
+    if (avctx->reget_buffer(avctx, &s->frame) < 0) {
+        av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
+        return -1;
     }
 
     /* loop over all block columns */
-    for (j = 0; j < v_blocks + (v_part?1:0); j++)
-    {
+    for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 
-        int hp = j*s->block_height; // horiz position in frame
-        int hs = (j<v_blocks)?s->block_height:v_part; // size of block
+        int hp = j * s->block_height; // horiz position in frame
+        int hs = (j < v_blocks) ? s->block_height : v_part; // size of block
 
 
         /* loop over all block rows */
-        for (i = 0; i < h_blocks + (h_part?1:0); i++)
-        {
-            int wp = i*s->block_width; // vert position in frame
-            int ws = (i<h_blocks)?s->block_width:h_part; // size of block
+        for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
+            int wp = i * s->block_width; // vert position in frame
+            int ws = (i < h_blocks) ? s->block_width : h_part; // size of block
 
             /* get the size of the compressed zlib chunk */
             int size = get_bits(&gb, 16);
@@ -193,30 +188,28 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
             } else {
                 /* decompress block */
                 int ret = inflateReset(&(s->zstream));
-                if (ret != Z_OK)
-                {
+                if (ret != Z_OK) {
                     av_log(avctx, AV_LOG_ERROR, "error in decompression (reset) of block %dx%d\n", i, j);
                     /* return -1; */
                 }
-                s->zstream.next_in = buf+(get_bits_count(&gb)/8);
-                s->zstream.avail_in = size;
-                s->zstream.next_out = s->tmpblock;
+                s->zstream.next_in   = buf + (get_bits_count(&gb) / 8);
+                s->zstream.avail_in  = size;
+                s->zstream.next_out  = s->tmpblock;
                 s->zstream.avail_out = s->block_size*3;
                 ret = inflate(&(s->zstream), Z_FINISH);
-                if (ret == Z_DATA_ERROR)
-                {
+                if (ret == Z_DATA_ERROR) {
                     av_log(avctx, AV_LOG_ERROR, "Zlib resync occurred\n");
                     inflateSync(&(s->zstream));
                     ret = inflate(&(s->zstream), Z_FINISH);
                 }
 
-                if ((ret != Z_OK) && (ret != Z_STREAM_END))
-                {
+                if ((ret != Z_OK) && (ret != Z_STREAM_END)) {
                     av_log(avctx, AV_LOG_ERROR, "error in decompression of block %dx%d: %d\n", i, j, ret);
                     /* return -1; */
                 }
-                copy_region(s->tmpblock, s->frame.data[0], s->image_height-(hp+hs+1), wp, hs, ws, s->frame.linesize[0]);
-                skip_bits_long(&gb, 8*size);   /* skip the consumed bits */
+                copy_region(s->tmpblock, s->frame.data[0], s->image_height - (hp + hs + 1),
+                            wp, hs, ws, s->frame.linesize[0]);
+                skip_bits_long(&gb, 8 * size);   /* skip the consumed bits */
             }
         }
     }
@@ -224,9 +217,9 @@ static int flashsv_decode_frame(AVCodecContext *avctx,
     *data_size = sizeof(AVFrame);
     *(AVFrame*)data = s->frame;
 
-    if ((get_bits_count(&gb)/8) != buf_size)
+    if ((get_bits_count(&gb) / 8) != buf_size)
         av_log(avctx, AV_LOG_ERROR, "buffer not fully consumed (%d != %d)\n",
-            buf_size, (get_bits_count(&gb)/8));
+               buf_size, (get_bits_count(&gb) / 8));
 
     /* report that the buffer was completely consumed */
     return buf_size;

libavcodec/flashsvenc.c

@@ -65,32 +65,33 @@
 
 typedef struct FlashSVContext {
     AVCodecContext *avctx;
-    uint8_t *previous_frame;
-    AVFrame frame;
-    int image_width, image_height;
-    int block_width, block_height;
-    uint8_t* tmpblock;
-    uint8_t* encbuffer;
-    int block_size;
-    z_stream zstream;
-    int last_key_frame;
+    uint8_t        *previous_frame;
+    AVFrame         frame;
+    int             image_width, image_height;
+    int             block_width, block_height;
+    uint8_t        *tmpblock;
+    uint8_t        *encbuffer;
+    int             block_size;
+    z_stream        zstream;
+    int             last_key_frame;
 } FlashSVContext;
 
-static int copy_region_enc(uint8_t *sptr, uint8_t *dptr,
-        int dx, int dy, int h, int w, int stride, uint8_t *pfptr) {
-    int i,j;
+static int copy_region_enc(uint8_t *sptr, uint8_t *dptr, int dx, int dy,
+                           int h, int w, int stride, uint8_t *pfptr)
+{
+    int i, j;
     uint8_t *nsptr;
     uint8_t *npfptr;
     int diff = 0;
 
-    for (i = dx+h; i > dx; i--) {
-        nsptr = sptr+(i*stride)+dy*3;
-        npfptr = pfptr+(i*stride)+dy*3;
-        for (j=0 ; j<w*3 ; j++) {
-            diff |=npfptr[j]^nsptr[j];
-            dptr[j] = nsptr[j];
+    for (i = dx + h; i > dx; i--) {
+        nsptr  = sptr  + (i * stride) + dy * 3;
+        npfptr = pfptr + (i * stride) + dy * 3;
+        for (j = 0; j < w * 3; j++) {
+            diff    |= npfptr[j] ^ nsptr[j];
+            dptr[j]  = nsptr[j];
         }
-        dptr += w*3;
+        dptr += w * 3;
     }
     if (diff)
         return 1;
@@ -111,13 +112,13 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
     // Needed if zlib unused or init aborted before deflateInit
     memset(&(s->zstream), 0, sizeof(z_stream));
 
-    s->last_key_frame=0;
+    s->last_key_frame = 0;
 
-    s->image_width = avctx->width;
+    s->image_width  = avctx->width;
     s->image_height = avctx->height;
 
-    s->tmpblock = av_mallocz(3*256*256);
-    s->encbuffer = av_mallocz(s->image_width*s->image_height*3);
+    s->tmpblock  = av_mallocz(3 * 256 * 256);
+    s->encbuffer = av_mallocz(s->image_width * s->image_height * 3);
 
     if (!s->tmpblock || !s->encbuffer) {
         av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
@@ -128,64 +129,67 @@ static av_cold int flashsv_encode_init(AVCodecContext *avctx)
 }
 
 
-static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf_size,
-     int block_width, int block_height, uint8_t *previous_frame, int* I_frame) {
+static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf,
+                            int buf_size, int block_width, int block_height,
+                            uint8_t *previous_frame, int *I_frame)
+{
 
     PutBitContext pb;
     int h_blocks, v_blocks, h_part, v_part, i, j;
     int buf_pos, res;
     int pred_blocks = 0;
 
-    init_put_bits(&pb, buf, buf_size*8);
+    init_put_bits(&pb, buf, buf_size * 8);
 
-    put_bits(&pb, 4, (block_width/16)-1);
+    put_bits(&pb,  4, (block_width / 16) - 1);
     put_bits(&pb, 12, s->image_width);
-    put_bits(&pb, 4, (block_height/16)-1);
+    put_bits(&pb,  4, (block_height / 16) - 1);
     put_bits(&pb, 12, s->image_height);
     flush_put_bits(&pb);
-    buf_pos=4;
+    buf_pos = 4;
 
-    h_blocks = s->image_width / block_width;
-    h_part = s->image_width % block_width;
+    h_blocks = s->image_width  / block_width;
+    h_part   = s->image_width  % block_width;
     v_blocks = s->image_height / block_height;
-    v_part = s->image_height % block_height;
+    v_part   = s->image_height % block_height;
 
     /* loop over all block columns */
-    for (j = 0; j < v_blocks + (v_part?1:0); j++)
-    {
+    for (j = 0; j < v_blocks + (v_part ? 1 : 0); j++) {
 
-        int hp = j*block_height; // horiz position in frame
-        int hs = (j<v_blocks)?block_height:v_part; // size of block
+        int hp = j * block_height; // horiz position in frame
+        int hs = (j < v_blocks) ? block_height : v_part; // size of block
 
         /* loop over all block rows */
-        for (i = 0; i < h_blocks + (h_part?1:0); i++)
-        {
-            int wp = i*block_width; // vert position in frame
-            int ws = (i<h_blocks)?block_width:h_part; // size of block
-            int ret=Z_OK;
+        for (i = 0; i < h_blocks + (h_part ? 1 : 0); i++) {
+            int wp  = i * block_width; // vert position in frame
+            int ws  = (i < h_blocks) ? block_width : h_part; // size of block
+            int ret = Z_OK;
             uint8_t *ptr;
 
-            ptr = buf+buf_pos;
+            ptr = buf + buf_pos;
 
-            //copy the block to the temp buffer before compression (if it differs from the previous frame's block)
-            res = copy_region_enc(p->data[0], s->tmpblock, s->image_height-(hp+hs+1), wp, hs, ws, p->linesize[0], previous_frame);
+            /* copy the block to the temp buffer before compression
+             * (if it differs from the previous frame's block) */
+            res = copy_region_enc(p->data[0], s->tmpblock,
+                                  s->image_height - (hp + hs + 1),
+                                  wp, hs, ws, p->linesize[0], previous_frame);
 
             if (res || *I_frame) {
                 unsigned long zsize;
-                zsize = 3*block_width*block_height;
-                ret = compress2(ptr+2, &zsize, s->tmpblock, 3*ws*hs, 9);
+                zsize = 3 * block_width * block_height;
+                ret   = compress2(ptr + 2, &zsize, s->tmpblock, 3 * ws * hs, 9);
 
 
                 //ret = deflateReset(&(s->zstream));
                 if (ret != Z_OK)
                     av_log(s->avctx, AV_LOG_ERROR, "error while compressing block %dx%d\n", i, j);
 
-                bytestream_put_be16(&ptr,(unsigned int)zsize);
-                buf_pos += zsize+2;
+                bytestream_put_be16(&ptr, (unsigned int) zsize);
+                buf_pos += zsize + 2;
                 //av_log(avctx, AV_LOG_ERROR, "buf_pos = %d\n", buf_pos);
             } else {
                 pred_blocks++;
-                bytestream_put_be16(&ptr,0);
+                bytestream_put_be16(&ptr, 0);
                 buf_pos += 2;
             }
         }
@@ -200,7 +204,8 @@ static int encode_bitstream(FlashSVContext *s, AVFrame *p, uint8_t *buf, int buf
 }
 
 
-static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_size, void *data)
+static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf,
+                                int buf_size, void *data)
 {
     FlashSVContext * const s = avctx->priv_data;
     AVFrame *pict = data;
@@ -214,7 +219,7 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
 
     /* First frame needs to be a keyframe */
     if (avctx->frame_number == 0) {
-        s->previous_frame = av_mallocz(FFABS(p->linesize[0])*s->image_height);
+        s->previous_frame = av_mallocz(FFABS(p->linesize[0]) * s->image_height);
         if (!s->previous_frame) {
             av_log(avctx, AV_LOG_ERROR, "Memory allocation failed.\n");
             return -1;
@@ -223,7 +228,7 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
     }
 
     if (p->linesize[0] < 0)
-        pfptr = s->previous_frame - ((s->image_height-1) * p->linesize[0]);
+        pfptr = s->previous_frame - ((s->image_height - 1) * p->linesize[0]);
     else
         pfptr = s->previous_frame;
 
@@ -234,29 +239,31 @@ static int flashsv_encode_frame(AVCodecContext *avctx, uint8_t *buf, int buf_siz
         }
     }
 
-    opt_w=4;
-    opt_h=4;
+    opt_w = 4;
+    opt_h = 4;
 
     if (buf_size < s->image_width*s->image_height*3) {
         //Conservative upper bound check for compressed data
-        av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n", buf_size, s->image_width*s->image_height*3);
+        av_log(avctx, AV_LOG_ERROR, "buf_size %d <  %d\n",
+               buf_size, s->image_width * s->image_height * 3);
         return -1;
     }
 
-    res = encode_bitstream(s, p, buf, buf_size, opt_w*16, opt_h*16, pfptr, &I_frame);
+    res = encode_bitstream(s, p, buf, buf_size, opt_w * 16, opt_h * 16, pfptr, &I_frame);
 
     //save the current frame
-    if(p->linesize[0] > 0)
-        memcpy(s->previous_frame, p->data[0], s->image_height*p->linesize[0]);
+    if (p->linesize[0] > 0)
+        memcpy(s->previous_frame, p->data[0], s->image_height * p->linesize[0]);
     else
-        memcpy(s->previous_frame, p->data[0] + p->linesize[0] * (s->image_height-1), s->image_height*FFABS(p->linesize[0]));
+        memcpy(s->previous_frame, p->data[0] + p->linesize[0] * (s->image_height - 1),
+               s->image_height * FFABS(p->linesize[0]));
 
     //mark the frame type so the muxer can mux it correctly
     if (I_frame) {
         p->pict_type = FF_I_TYPE;
         p->key_frame = 1;
         s->last_key_frame = avctx->frame_number;
-        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n",avctx->frame_number);
+        av_log(avctx, AV_LOG_DEBUG, "Inserting key frame at frame %d\n", avctx->frame_number);
     } else {
         p->pict_type = FF_P_TYPE;
         p->key_frame = 0;