h261: K&R formatting and prettyprinting cosmetics

6 files changed, 476 insertions, 454 deletions

diff --git a/libavcodec/h261.c b/libavcodec/h261.c
index 1ffd64a5ec..f1b88001ea 100644
--- a/libavcodec/h261.c
+++ b/libavcodec/h261.c
@@ -28,51 +28,52 @@
 #include "avcodec.h"
 #include "h261.h"
 
-#define IS_FIL(a)    ((a)&MB_TYPE_H261_FIL)
+#define IS_FIL(a)    ((a) & MB_TYPE_H261_FIL)
 
-uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
+uint8_t ff_h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
 
 static void h261_loop_filter(uint8_t *src, int stride)
 {
-    int x,y,xy,yz;
+    int x, y, xy, yz;
     int temp[64];
 
-    for(x=0; x<8; x++){
-        temp[x      ] = 4*src[x           ];
-        temp[x + 7*8] = 4*src[x + 7*stride];
+    for (x = 0; x < 8; x++) {
+        temp[x]         = 4 * src[x];
+        temp[x + 7 * 8] = 4 * src[x + 7 * stride];
     }
-    for(y=1; y<7; y++){
-        for(x=0; x<8; x++){
-            xy = y * stride + x;
-            yz = y * 8 + x;
-            temp[yz] = src[xy - stride] + 2*src[xy] + src[xy + stride];
+    for (y = 1; y < 7; y++) {
+        for (x = 0; x < 8; x++) {
+            xy       = y * stride + x;
+            yz       = y * 8      + x;
+            temp[yz] = src[xy - stride] + 2 * src[xy] + src[xy + stride];
         }
     }
 
-    for(y=0; y<8; y++){
-        src[  y*stride] = (temp[  y*8] + 2)>>2;
-        src[7+y*stride] = (temp[7+y*8] + 2)>>2;
-        for(x=1; x<7; x++){
-            xy = y * stride + x;
-            yz = y * 8 + x;
-            src[xy] = (temp[yz-1] + 2*temp[yz] + temp[yz+1] + 8)>>4;
+    for (y = 0; y < 8; y++) {
+        src[y * stride]     = (temp[y * 8]     + 2) >> 2;
+        src[y * stride + 7] = (temp[y * 8 + 7] + 2) >> 2;
+        for (x = 1; x < 7; x++) {
+            xy      = y * stride + x;
+            yz      = y * 8      + x;
+            src[xy] = (temp[yz - 1] + 2 * temp[yz] + temp[yz + 1] + 8) >> 4;
         }
     }
 }
 
-void ff_h261_loop_filter(MpegEncContext *s){
-    H261Context * h= (H261Context*)s;
-    const int linesize  = s->linesize;
-    const int uvlinesize= s->uvlinesize;
-    uint8_t *dest_y = s->dest[0];
-    uint8_t *dest_cb= s->dest[1];
-    uint8_t *dest_cr= s->dest[2];
+void ff_h261_loop_filter(MpegEncContext *s)
+{
+    H261Context *h       = (H261Context *)s;
+    const int linesize   = s->linesize;
+    const int uvlinesize = s->uvlinesize;
+    uint8_t *dest_y      = s->dest[0];
+    uint8_t *dest_cb     = s->dest[1];
+    uint8_t *dest_cr     = s->dest[2];
 
-    if(!(IS_FIL (h->mtype)))
+    if (!(IS_FIL(h->mtype)))
         return;
 
     h261_loop_filter(dest_y,                    linesize);
-    h261_loop_filter(dest_y                + 8, linesize);
+    h261_loop_filter(dest_y + 8,                linesize);
     h261_loop_filter(dest_y + 8 * linesize,     linesize);
     h261_loop_filter(dest_y + 8 * linesize + 8, linesize);
     h261_loop_filter(dest_cb, uvlinesize);
diff --git a/libavcodec/h261.h b/libavcodec/h261.h
index b5201b1df6..df9cbe8ac0 100644
--- a/libavcodec/h261.h
+++ b/libavcodec/h261.h
@@ -33,7 +33,7 @@
 /**
  * H261Context
  */
-typedef struct H261Context{
+typedef struct H261Context {
     MpegEncContext s;
 
     int current_mba;
@@ -44,11 +44,11 @@ typedef struct H261Context{
     int current_mv_y;
     int gob_number;
     int gob_start_code_skipped; // 1 if gob start code is already read before gob header is read
-}H261Context;
+} H261Context;
 
 #define MB_TYPE_H261_FIL 0x800000
 
-extern uint8_t ff_h261_rl_table_store[2][2*MAX_RUN + MAX_LEVEL + 3];
+extern uint8_t ff_h261_rl_table_store[2][2 * MAX_RUN + MAX_LEVEL + 3];
 
 void ff_h261_loop_filter(MpegEncContext *s);
 
diff --git a/libavcodec/h261_parser.c b/libavcodec/h261_parser.c
index 8a507ee8f2..2469424c1a 100644
--- a/libavcodec/h261_parser.c
+++ b/libavcodec/h261_parser.c
@@ -27,38 +27,39 @@
 
 #include "parser.h"
 
-
-static int h261_find_frame_end(ParseContext *pc, AVCodecContext* avctx, const uint8_t *buf, int buf_size){
+static int h261_find_frame_end(ParseContext *pc, AVCodecContext *avctx,
+                               const uint8_t *buf, int buf_size)
+{
     int vop_found, i, j;
     uint32_t state;
 
-    vop_found= pc->frame_start_found;
-    state= pc->state;
+    vop_found = pc->frame_start_found;
+    state     = pc->state;
 
-    for(i=0; i<buf_size && !vop_found; i++){
-        state= (state<<8) | buf[i];
-        for(j=0; j<8; j++){
-            if(((state>>j)&0xFFFFF0) == 0x000100){
-                vop_found=1;
+    for (i = 0; i < buf_size && !vop_found; i++) {
+        state = (state << 8) | buf[i];
+        for (j = 0; j < 8; j++) {
+            if (((state >> j) & 0xFFFFF0) == 0x000100) {
+                vop_found = 1;
                 break;
             }
         }
     }
-    if(vop_found){
-        for(; i<buf_size; i++){
-            state= (state<<8) | buf[i];
-            for(j=0; j<8; j++){
-                if(((state>>j)&0xFFFFF0) == 0x000100){
-                    pc->frame_start_found=0;
-                    pc->state= (state>>(3*8))+0xFF00;
-                    return i-2;
+    if (vop_found) {
+        for (; i < buf_size; i++) {
+            state = (state << 8) | buf[i];
+            for (j = 0; j < 8; j++) {
+                if (((state >> j) & 0xFFFFF0) == 0x000100) {
+                    pc->frame_start_found = 0;
+                    pc->state             = (state >> (3 * 8)) + 0xFF00;
+                    return i - 2;
                 }
             }
         }
     }
 
-    pc->frame_start_found= vop_found;
-    pc->state= state;
+    pc->frame_start_found = vop_found;
+    pc->state             = state;
     return END_NOT_FOUND;
 }
 
@@ -70,13 +71,13 @@ static int h261_parse(AVCodecParserContext *s,
     ParseContext *pc = s->priv_data;
     int next;
 
-    next= h261_find_frame_end(pc,avctx, buf, buf_size);
+    next = h261_find_frame_end(pc, avctx, buf, buf_size);
     if (ff_combine_frame(pc, next, &buf, &buf_size) < 0) {
-        *poutbuf = NULL;
+        *poutbuf      = NULL;
         *poutbuf_size = 0;
         return buf_size;
     }
-    *poutbuf = buf;
+    *poutbuf      = buf;
     *poutbuf_size = buf_size;
     return next;
 }
diff --git a/libavcodec/h261data.h b/libavcodec/h261data.h
index 2c610151c7..bf0b20959b 100644
--- a/libavcodec/h261data.h
+++ b/libavcodec/h261data.h
@@ -28,6 +28,7 @@
 #define AVCODEC_H261DATA_H
 
 #include <stdint.h>
+
 #include "h261.h"
 
 // H.261 VLC table for macroblock addressing
@@ -41,8 +42,8 @@ static const uint8_t h261_mba_code[35] = {
     32, 31, 30, 29,
     28, 27, 26, 25,
     24,
-    15,           //(MBA stuffing)
-    1             //(start code)
+    15, // (MBA stuffing)
+     1  // (start code)
 };
 
 static const uint8_t h261_mba_bits[35] = {
@@ -55,102 +56,100 @@ static const uint8_t h261_mba_bits[35] = {
     11, 11, 11, 11,
     11, 11, 11, 11,
     11,
-    11,           //(MBA stuffing)
-    16            //(start code)
+    11, // (MBA stuffing)
+    16  // (start code)
 };
 
-//H.261 VLC table for macroblock type
+// H.261 VLC table for macroblock type
 static const uint8_t h261_mtype_code[10] = {
-    1,  1,  1,  1,
-    1,  1,  1,  1,
-    1,  1
+    1, 1, 1, 1,
+    1, 1, 1, 1,
+    1, 1
 };
 
 static const uint8_t h261_mtype_bits[10] = {
-    4,  7,  1,  5,
-    9,  8, 10,  3,
-    2,  6
+    4, 7,  1, 5,
+    9, 8, 10, 3,
+    2, 6
 };
 
-static const int h261_mtype_map[10]= {
-        MB_TYPE_INTRA4x4,
-        MB_TYPE_INTRA4x4  |  MB_TYPE_QUANT,
-                                               MB_TYPE_CBP,
-                             MB_TYPE_QUANT  |  MB_TYPE_CBP,
-                                                               MB_TYPE_16x16,
-                                               MB_TYPE_CBP  |  MB_TYPE_16x16,
-                             MB_TYPE_QUANT  |  MB_TYPE_CBP  |  MB_TYPE_16x16,
-                                                               MB_TYPE_16x16  |  MB_TYPE_H261_FIL,
-                                               MB_TYPE_CBP  |  MB_TYPE_16x16  |  MB_TYPE_H261_FIL,
-                             MB_TYPE_QUANT  |  MB_TYPE_CBP  |  MB_TYPE_16x16  |  MB_TYPE_H261_FIL
+static const int h261_mtype_map[10] = {
+    MB_TYPE_INTRA4x4,
+    MB_TYPE_INTRA4x4 | MB_TYPE_QUANT,
+    MB_TYPE_CBP,
+    MB_TYPE_CBP | MB_TYPE_QUANT,
+    MB_TYPE_16x16,
+    MB_TYPE_16x16 | MB_TYPE_CBP,
+    MB_TYPE_16x16 | MB_TYPE_CBP | MB_TYPE_QUANT,
+    MB_TYPE_16x16 | MB_TYPE_H261_FIL,
+    MB_TYPE_16x16 | MB_TYPE_H261_FIL | MB_TYPE_CBP,
+    MB_TYPE_16x16 | MB_TYPE_H261_FIL | MB_TYPE_CBP | MB_TYPE_QUANT
 };
 
-//H.261 VLC table for motion vectors
+// H.261 VLC table for motion vectors
 static const uint8_t h261_mv_tab[17][2] = {
-    {1,1}, {1,2}, {1,3}, {1,4}, {3,6}, {5,7}, {4,7}, {3,7},
-    {11,9}, {10,9}, {9,9}, {17,10}, {16,10}, {15,10}, {14,10}, {13,10}, {12,10}
+    {  1, 1 }, {  1, 2 }, { 1, 3 }, {  1,  4 }, {  3,  6 }, {  5,  7 }, {  4,  7 }, {  3,  7 },
+    { 11, 9 }, { 10, 9 }, { 9, 9 }, { 17, 10 }, { 16, 10 }, { 15, 10 }, { 14, 10 }, { 13, 10 }, { 12, 10 }
 };
 
-static const int mvmap[17] =
-{
+static const int mvmap[17] = {
     0, -1, -2, -3, -4, -5, -6, -7, -8, -9, -10, -11, -12, -13, -14, -15, -16
 };
 
-//H.261 VLC table for coded block pattern
-static const uint8_t h261_cbp_tab[63][2] =
-{
-    {11,5}, {9,5}, {13,6}, {13,4}, {23,7}, {19,7}, {31,8}, {12,4},
-    {22,7}, {18,7}, {30,8}, {19,5}, {27,8}, {23,8}, {19,8}, {11,4},
-    {21,7}, {17,7}, {29,8}, {17,5}, {25,8}, {21,8}, {17,8}, {15,6},
-    {15,8}, {13,8}, {3,9}, {15,5}, {11,8}, {7,8}, {7,9}, {10,4},
-    {20,7}, {16,7}, {28,8}, {14,6}, {14,8}, {12,8}, {2,9}, {16,5},
-    {24,8}, {20,8}, {16,8}, {14,5}, {10,8}, {6,8}, {6,9}, {18,5},
-    {26,8}, {22,8}, {18,8}, {13,5}, {9,8}, {5,8}, {5,9}, {12,5},
-    {8,8}, {4,8}, {4,9}, {7,3}, {10,5}, {8,5}, {12,6}
+// H.261 VLC table for coded block pattern
+static const uint8_t h261_cbp_tab[63][2] = {
+    { 11, 5 }, {  9, 5 }, { 13, 6 }, { 13, 4 }, { 23, 7 }, { 19, 7 }, { 31, 8 }, { 12, 4 },
+    { 22, 7 }, { 18, 7 }, { 30, 8 }, { 19, 5 }, { 27, 8 }, { 23, 8 }, { 19, 8 }, { 11, 4 },
+    { 21, 7 }, { 17, 7 }, { 29, 8 }, { 17, 5 }, { 25, 8 }, { 21, 8 }, { 17, 8 }, { 15, 6 },
+    { 15, 8 }, { 13, 8 }, {  3, 9 }, { 15, 5 }, { 11, 8 }, {  7, 8 }, {  7, 9 }, { 10, 4 },
+    { 20, 7 }, { 16, 7 }, { 28, 8 }, { 14, 6 }, { 14, 8 }, { 12, 8 }, {  2, 9 }, { 16, 5 },
+    { 24, 8 }, { 20, 8 }, { 16, 8 }, { 14, 5 }, { 10, 8 }, {  6, 8 }, {  6, 9 }, { 18, 5 },
+    { 26, 8 }, { 22, 8 }, { 18, 8 }, { 13, 5 }, {  9, 8 }, {  5, 8 }, {  5, 9 }, { 12, 5 },
+    {  8, 8 }, {  4, 8 }, {  4, 9 }, {  7, 3 }, { 10, 5 }, {  8, 5 }, { 12, 6 }
 };
 
-//H.261 VLC table for transform coefficients
+// H.261 VLC table for transform coefficients
 static const uint16_t h261_tcoeff_vlc[65][2] = {
-{ 0x2, 2 }, { 0x3, 2 },{ 0x4, 4 },{ 0x5, 5 },
-{ 0x6, 7 },{ 0x26, 8 },{ 0x21, 8 },{ 0xa, 10 },
-{ 0x1d, 12 },{ 0x18, 12 },{ 0x13, 12 },{ 0x10 , 12 },
-{ 0x1a, 13},{ 0x19, 13 }, { 0x18, 13 }, { 0x17, 13 },
-{ 0x3, 3 }, { 0x6, 6 }, { 0x25 , 8 }, { 0xc, 10 },
-{ 0x1b, 12 }, { 0x16, 13 }, { 0x15, 13 }, { 0x5, 4},
-{ 0x4, 7}, { 0xb, 10 }, { 0x14, 12 }, { 0x14, 13 },
-{ 0x7, 5 }, { 0x24, 8 }, { 0x1c, 12 }, { 0x13, 13 },
-{ 0x6, 5 }, { 0xf, 10 }, { 0x12, 12}, { 0x7, 6},
-{ 0x9 , 10 }, { 0x12, 13 }, { 0x5, 6 }, { 0x1e, 12 },
-{ 0x4, 6 }, { 0x15, 12 }, { 0x7, 7 }, { 0x11, 12},
-{ 0x5, 7 }, { 0x11, 13 }, { 0x27, 8 }, { 0x10, 13 },
-{ 0x23, 8 }, { 0x22, 8 }, { 0x20, 8 }, { 0xe , 10 },
-{ 0xd, 10 }, { 0x8, 10 },{ 0x1f, 12 }, { 0x1a, 12 },
-{ 0x19, 12 }, { 0x17, 12 }, { 0x16, 12}, { 0x1f, 13},
-{ 0x1e, 13 }, { 0x1d, 13 }, { 0x1c, 13}, { 0x1b, 13},
-{ 0x1, 6 }                                             //escape
+    {  0x2,  2 }, {  0x3,  2 }, {  0x4,  4 }, {  0x5,  5 },
+    {  0x6,  7 }, { 0x26,  8 }, { 0x21,  8 }, {  0xa, 10 },
+    { 0x1d, 12 }, { 0x18, 12 }, { 0x13, 12 }, { 0x10, 12 },
+    { 0x1a, 13 }, { 0x19, 13 }, { 0x18, 13 }, { 0x17, 13 },
+    {  0x3,  3 }, {  0x6,  6 }, { 0x25,  8 }, {  0xc, 10 },
+    { 0x1b, 12 }, { 0x16, 13 }, { 0x15, 13 }, {  0x5,  4 },
+    {  0x4,  7 }, {  0xb, 10 }, { 0x14, 12 }, { 0x14, 13 },
+    {  0x7,  5 }, { 0x24,  8 }, { 0x1c, 12 }, { 0x13, 13 },
+    {  0x6,  5 }, {  0xf, 10 }, { 0x12, 12 }, {  0x7,  6 },
+    {  0x9, 10 }, { 0x12, 13 }, {  0x5,  6 }, { 0x1e, 12 },
+    {  0x4,  6 }, { 0x15, 12 }, {  0x7,  7 }, { 0x11, 12 },
+    {  0x5,  7 }, { 0x11, 13 }, { 0x27,  8 }, { 0x10, 13 },
+    { 0x23,  8 }, { 0x22,  8 }, { 0x20,  8 }, {  0xe, 10 },
+    {  0xd, 10 }, {  0x8, 10 }, { 0x1f, 12 }, { 0x1a, 12 },
+    { 0x19, 12 }, { 0x17, 12 }, { 0x16, 12 }, { 0x1f, 13 },
+    { 0x1e, 13 }, { 0x1d, 13 }, { 0x1c, 13 }, { 0x1b, 13 },
+    {  0x1,  6 }  // escape
 };
 
 static const int8_t h261_tcoeff_level[64] = {
-    0,  1,  2,  3,  4,  5,  6,  7,
-    8,  9, 10, 11, 12, 13, 14, 15,
-    1,  2,  3,  4,  5,  6,  7,  1,
-    2,  3,  4,  5,  1,  2,  3,  4,
-    1,  2,  3,  1,  2,  3,  1,  2,
-    1,  2,  1,  2,  1,  2,  1,  2,
-    1,  1,  1,  1,  1,  1,  1,  1,
-    1,  1,  1,  1,  1,  1,  1,  1
+    0, 1,  2,  3,  4,  5,  6,  7,
+    8, 9, 10, 11, 12, 13, 14, 15,
+    1, 2,  3,  4,  5,  6,  7,  1,
+    2, 3,  4,  5,  1,  2,  3,  4,
+    1, 2,  3,  1,  2,  3,  1,  2,
+    1, 2,  1,  2,  1,  2,  1,  2,
+    1, 1,  1,  1,  1,  1,  1,  1,
+    1, 1,  1,  1,  1,  1,  1,  1
 };
 
 static const int8_t h261_tcoeff_run[64] = {
-    0,
-    0,  0,  0,  0,  0,  0,  0,  0,
-    0,  0,  0,  0,  0,  0,  0,  1,
-    1,  1,  1,  1,  1,  1,  2,  2,
-    2,  2,  2,  3,  3,  3,  3,  4,
-    4,  4,  5,  5,  5,  6,  6,  7,
-    7,  8,  8,  9,  9, 10, 10, 11,
-   12, 13, 14, 15, 16, 17, 18, 19,
-   20, 21, 22, 23, 24, 25, 26
+     0,
+     0,  0,  0,  0,  0,  0,  0,  0,
+     0,  0,  0,  0,  0,  0,  0,  1,
+     1,  1,  1,  1,  1,  1,  2,  2,
+     2,  2,  2,  3,  3,  3,  3,  4,
+     4,  4,  5,  5,  5,  6,  6,  7,
+     7,  8,  8,  9,  9, 10, 10, 11,
+    12, 13, 14, 15, 16, 17, 18, 19,
+    20, 21, 22, 23, 24, 25, 26
 };
 
 static RLTable h261_rl_tcoeff = {
diff --git a/libavcodec/h261dec.c b/libavcodec/h261dec.c
index 2592976407..d1ce28fb3e 100644
--- a/libavcodec/h261dec.c
+++ b/libavcodec/h261dec.c
@@ -44,47 +44,46 @@ static VLC h261_mtype_vlc;
 static VLC h261_mv_vlc;
 static VLC h261_cbp_vlc;
 
-static int h261_decode_block(H261Context * h, int16_t * block, int n, int coded);
+static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded);
 
-static av_cold void h261_decode_init_vlc(H261Context *h){
+static av_cold void h261_decode_init_vlc(H261Context *h)
+{
     static int done = 0;
 
-    if(!done){
+    if (!done) {
         done = 1;
         INIT_VLC_STATIC(&h261_mba_vlc, H261_MBA_VLC_BITS, 35,
-                 h261_mba_bits, 1, 1,
-                 h261_mba_code, 1, 1, 662);
+                        h261_mba_bits, 1, 1,
+                        h261_mba_code, 1, 1, 662);
         INIT_VLC_STATIC(&h261_mtype_vlc, H261_MTYPE_VLC_BITS, 10,
-                 h261_mtype_bits, 1, 1,
-                 h261_mtype_code, 1, 1, 80);
+                        h261_mtype_bits, 1, 1,
+                        h261_mtype_code, 1, 1, 80);
         INIT_VLC_STATIC(&h261_mv_vlc, H261_MV_VLC_BITS, 17,
-                 &h261_mv_tab[0][1], 2, 1,
-                 &h261_mv_tab[0][0], 2, 1, 144);
+                        &h261_mv_tab[0][1], 2, 1,
+                        &h261_mv_tab[0][0], 2, 1, 144);
         INIT_VLC_STATIC(&h261_cbp_vlc, H261_CBP_VLC_BITS, 63,
-                 &h261_cbp_tab[0][1], 2, 1,
-                 &h261_cbp_tab[0][0], 2, 1, 512);
+                        &h261_cbp_tab[0][1], 2, 1,
+                        &h261_cbp_tab[0][0], 2, 1, 512);
         ff_init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store);
         INIT_VLC_RL(h261_rl_tcoeff, 552);
     }
 }
 
-static av_cold int h261_decode_init(AVCodecContext *avctx){
-    H261Context *h= avctx->priv_data;
-    MpegEncContext * const s = &h->s;
+static av_cold int h261_decode_init(AVCodecContext *avctx)
+{
+    H261Context *h          = avctx->priv_data;
+    MpegEncContext *const s = &h->s;
 
     // set defaults
     ff_MPV_decode_defaults(s);
-    s->avctx = avctx;
-
-    s->width  = s->avctx->coded_width;
-    s->height = s->avctx->coded_height;
-    s->codec_id = s->avctx->codec->id;
-
-    s->out_format = FMT_H261;
-    s->low_delay= 1;
-    avctx->pix_fmt= AV_PIX_FMT_YUV420P;
-
-    s->codec_id= avctx->codec->id;
+    s->avctx       = avctx;
+    s->width       = s->avctx->coded_width;
+    s->height      = s->avctx->coded_height;
+    s->codec_id    = s->avctx->codec->id;
+    s->out_format  = FMT_H261;
+    s->low_delay   = 1;
+    avctx->pix_fmt = AV_PIX_FMT_YUV420P;
+    s->codec_id    = avctx->codec->id;
 
     h261_decode_init_vlc(h);
 
@@ -97,14 +96,15 @@ static av_cold int h261_decode_init(AVCodecContext *avctx){
  * Decode the group of blocks header or slice header.
  * @return <0 if an error occurred
  */
-static int h261_decode_gob_header(H261Context *h){
+static int h261_decode_gob_header(H261Context *h)
+{
     unsigned int val;
-    MpegEncContext * const s = &h->s;
+    MpegEncContext *const s = &h->s;
 
-    if ( !h->gob_start_code_skipped ){
+    if (!h->gob_start_code_skipped) {
         /* Check for GOB Start Code */
         val = show_bits(&s->gb, 15);
-        if(val)
+        if (val)
             return -1;
 
         /* We have a GBSC */
@@ -114,34 +114,34 @@ static int h261_decode_gob_header(H261Context *h){
     h->gob_start_code_skipped = 0;
 
     h->gob_number = get_bits(&s->gb, 4); /* GN */
-    s->qscale = get_bits(&s->gb, 5); /* GQUANT */
+    s->qscale     = get_bits(&s->gb, 5); /* GQUANT */
 
     /* Check if gob_number is valid */
-    if (s->mb_height==18){ //cif
-        if ((h->gob_number<=0) || (h->gob_number>12))
+    if (s->mb_height == 18) { // CIF
+        if ((h->gob_number <= 0) || (h->gob_number > 12))
             return -1;
-    }
-    else{ //qcif
-        if ((h->gob_number!=1) && (h->gob_number!=3) && (h->gob_number!=5))
+    } else { // QCIF
+        if ((h->gob_number != 1) && (h->gob_number != 3) &&
+            (h->gob_number != 5))
             return -1;
     }
 
     /* GEI */
-    while (get_bits1(&s->gb) != 0) {
+    while (get_bits1(&s->gb) != 0)
         skip_bits(&s->gb, 8);
-    }
 
-    if(s->qscale==0) {
+    if (s->qscale == 0) {
         av_log(s->avctx, AV_LOG_ERROR, "qscale has forbidden 0 value\n");
         if (s->avctx->err_recognition & AV_EF_BITSTREAM)
             return -1;
     }
 
-    // For the first transmitted macroblock in a GOB, MBA is the absolute address. For
-    // subsequent macroblocks, MBA is the difference between the absolute addresses of
-    // the macroblock and the last transmitted macroblock.
+    /* For the first transmitted macroblock in a GOB, MBA is the absolute
+     * address. For subsequent macroblocks, MBA is the difference between
+     * the absolute addresses of the macroblock and the last transmitted
+     * macroblock. */
     h->current_mba = 0;
-    h->mba_diff = 0;
+    h->mba_diff    = 0;
 
     return 0;
 }
@@ -150,35 +150,35 @@ static int h261_decode_gob_header(H261Context *h){
  * Decode the group of blocks / video packet header.
  * @return <0 if no resync found
  */
-static int ff_h261_resync(H261Context *h){
-    MpegEncContext * const s = &h->s;
+static int ff_h261_resync(H261Context *h)
+{
+    MpegEncContext *const s = &h->s;
     int left, ret;
 
-    if ( h->gob_start_code_skipped ){
-        ret= h261_decode_gob_header(h);
-        if(ret>=0)
+    if (h->gob_start_code_skipped) {
+        ret = h261_decode_gob_header(h);
+        if (ret >= 0)
             return 0;
-    }
-    else{
-        if(show_bits(&s->gb, 15)==0){
-            ret= h261_decode_gob_header(h);
-            if(ret>=0)
+    } else {
+        if (show_bits(&s->gb, 15) == 0) {
+            ret = h261_decode_gob_header(h);
+            if (ret >= 0)
                 return 0;
         }
-        //OK, it is not where it is supposed to be ...
-        s->gb= s->last_resync_gb;
+        // OK, it is not where it is supposed to be ...
+        s->gb = s->last_resync_gb;
         align_get_bits(&s->gb);
-        left= get_bits_left(&s->gb);
+        left = get_bits_left(&s->gb);
 
-        for(;left>15+1+4+5; left-=8){
-            if(show_bits(&s->gb, 15)==0){
-                GetBitContext bak= s->gb;
+        for (; left > 15 + 1 + 4 + 5; left -= 8) {
+            if (show_bits(&s->gb, 15) == 0) {
+                GetBitContext bak = s->gb;
 
-                ret= h261_decode_gob_header(h);
-                if(ret>=0)
+                ret = h261_decode_gob_header(h);
+                if (ret >= 0)
                     return 0;
 
-                s->gb= bak;
+                s->gb = bak;
             }
             skip_bits(&s->gb, 8);
         }
@@ -191,32 +191,32 @@ static int ff_h261_resync(H261Context *h){
  * Decode skipped macroblocks.
  * @return 0
  */
-static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
+static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2)
 {
-    MpegEncContext * const s = &h->s;
+    MpegEncContext *const s = &h->s;
     int i;
 
     s->mb_intra = 0;
 
-    for(i=mba1; i<mba2; i++){
+    for (i = mba1; i < mba2; i++) {
         int j, xy;
 
-        s->mb_x= ((h->gob_number-1) % 2) * 11 + i % 11;
-        s->mb_y= ((h->gob_number-1) / 2) * 3 + i / 11;
-        xy = s->mb_x + s->mb_y * s->mb_stride;
+        s->mb_x = ((h->gob_number - 1) % 2) * 11 + i % 11;
+        s->mb_y = ((h->gob_number - 1) / 2) * 3 + i / 11;
+        xy      = s->mb_x + s->mb_y * s->mb_stride;
         ff_init_block_index(s);
         ff_update_block_index(s);
 
-        for(j=0;j<6;j++)
+        for (j = 0; j < 6; j++)
             s->block_last_index[j] = -1;
 
-        s->mv_dir = MV_DIR_FORWARD;
-        s->mv_type = MV_TYPE_16X16;
+        s->mv_dir                      = MV_DIR_FORWARD;
+        s->mv_type                     = MV_TYPE_16X16;
         s->current_picture.mb_type[xy] = MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
-        s->mv[0][0][0] = 0;
-        s->mv[0][0][1] = 0;
-        s->mb_skipped = 1;
-        h->mtype &= ~MB_TYPE_H261_FIL;
+        s->mv[0][0][0]                 = 0;
+        s->mv[0][0][1]                 = 0;
+        s->mb_skipped                  = 1;
+        h->mtype                      &= ~MB_TYPE_H261_FIL;
 
         ff_MPV_decode_mb(s, s->block);
     }
@@ -224,44 +224,48 @@ static int h261_decode_mb_skipped(H261Context *h, int mba1, int mba2 )
     return 0;
 }
 
-static int decode_mv_component(GetBitContext *gb, int v){
+static int decode_mv_component(GetBitContext *gb, int v)
+{
     int mv_diff = get_vlc2(gb, h261_mv_vlc.table, H261_MV_VLC_BITS, 2);
 
     /* check if mv_diff is valid */
-    if ( mv_diff < 0 )
+    if (mv_diff < 0)
         return v;
 
     mv_diff = mvmap[mv_diff];
 
-    if(mv_diff && !get_bits1(gb))
-        mv_diff= -mv_diff;
+    if (mv_diff && !get_bits1(gb))
+        mv_diff = -mv_diff;
 
     v += mv_diff;
-    if     (v <=-16) v+= 32;
-    else if(v >= 16) v-= 32;
+    if (v <= -16)
+        v += 32;
+    else if (v >= 16)
+        v -= 32;
 
     return v;
 }
 
-static int h261_decode_mb(H261Context *h){
-    MpegEncContext * const s = &h->s;
+static int h261_decode_mb(H261Context *h)
+{
+    MpegEncContext *const s = &h->s;
     int i, cbp, xy;
 
     cbp = 63;
     // Read mba
-    do{
-        h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table, H261_MBA_VLC_BITS, 2);
+    do {
+        h->mba_diff = get_vlc2(&s->gb, h261_mba_vlc.table,
+                               H261_MBA_VLC_BITS, 2);
 
         /* Check for slice end */
         /* NOTE: GOB can be empty (no MB data) or exist only of MBA_stuffing */
-        if (h->mba_diff == MBA_STARTCODE){ // start code
+        if (h->mba_diff == MBA_STARTCODE) { // start code
             h->gob_start_code_skipped = 1;
             return SLICE_END;
         }
-    }
-    while( h->mba_diff == MBA_STUFFING ); // stuffing
+    } while (h->mba_diff == MBA_STUFFING); // stuffing
 
-    if ( h->mba_diff < 0 ){
+    if (h->mba_diff < 0) {
         if (get_bits_left(&s->gb) <= 7)
             return SLICE_END;
 
@@ -269,15 +273,15 @@ static int h261_decode_mb(H261Context *h){
         return SLICE_ERROR;
     }
 
-    h->mba_diff += 1;
+    h->mba_diff    += 1;
     h->current_mba += h->mba_diff;
 
-    if ( h->current_mba > MBA_STUFFING )
+    if (h->current_mba > MBA_STUFFING)
         return SLICE_ERROR;
 
-    s->mb_x= ((h->gob_number-1) % 2) * 11 + ((h->current_mba-1) % 11);
-    s->mb_y= ((h->gob_number-1) / 2) * 3 + ((h->current_mba-1) / 11);
-    xy = s->mb_x + s->mb_y * s->mb_stride;
+    s->mb_x = ((h->gob_number - 1) % 2) * 11 + ((h->current_mba - 1) % 11);
+    s->mb_y = ((h->gob_number - 1) / 2) * 3 + ((h->current_mba - 1) / 11);
+    xy      = s->mb_x + s->mb_y * s->mb_stride;
     ff_init_block_index(s);
     ff_update_block_index(s);
 
@@ -286,64 +290,62 @@ static int h261_decode_mb(H261Context *h){
     h->mtype = h261_mtype_map[h->mtype];
 
     // Read mquant
-    if ( IS_QUANT ( h->mtype ) ){
+    if (IS_QUANT(h->mtype))
         ff_set_qscale(s, get_bits(&s->gb, 5));
-    }
 
     s->mb_intra = IS_INTRA4x4(h->mtype);
 
     // Read mv
-    if ( IS_16X16 ( h->mtype ) ){
-        // Motion vector data is included for all MC macroblocks. MVD is obtained from the macroblock vector by subtracting the
-        // vector of the preceding macroblock. For this calculation the vector of the preceding macroblock is regarded as zero in the
-        // following three situations:
-        // 1) evaluating MVD for macroblocks 1, 12 and 23;
-        // 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
-        // 3) MTYPE of the previous macroblock was not MC.
-        if ( ( h->current_mba == 1 ) || ( h->current_mba == 12 ) || ( h->current_mba == 23 ) ||
-             ( h->mba_diff != 1))
-        {
+    if (IS_16X16(h->mtype)) {
+        /* Motion vector data is included for all MC macroblocks. MVD is
+         * obtained from the macroblock vector by subtracting the vector
+         * of the preceding macroblock. For this calculation the vector
+         * of the preceding macroblock is regarded as zero in the
+         * following three situations:
+         * 1) evaluating MVD for macroblocks 1, 12 and 23;
+         * 2) evaluating MVD for macroblocks in which MBA does not represent a difference of 1;
+         * 3) MTYPE of the previous macroblock was not MC. */
+        if ((h->current_mba ==  1) || (h->current_mba == 12) ||
+            (h->current_mba == 23) || (h->mba_diff != 1)) {
             h->current_mv_x = 0;
             h->current_mv_y = 0;
         }
 
-        h->current_mv_x= decode_mv_component(&s->gb, h->current_mv_x);
-        h->current_mv_y= decode_mv_component(&s->gb, h->current_mv_y);
-    }else{
+        h->current_mv_x = decode_mv_component(&s->gb, h->current_mv_x);
+        h->current_mv_y = decode_mv_component(&s->gb, h->current_mv_y);
+    } else {
         h->current_mv_x = 0;
         h->current_mv_y = 0;
     }
 
     // Read cbp
-    if ( HAS_CBP( h->mtype ) ){
+    if (HAS_CBP(h->mtype))
         cbp = get_vlc2(&s->gb, h261_cbp_vlc.table, H261_CBP_VLC_BITS, 2) + 1;
-    }
 
-    if(s->mb_intra){
+    if (s->mb_intra) {
         s->current_picture.mb_type[xy] = MB_TYPE_INTRA;
         goto intra;
     }
 
     //set motion vectors
-    s->mv_dir = MV_DIR_FORWARD;
-    s->mv_type = MV_TYPE_16X16;
+    s->mv_dir                      = MV_DIR_FORWARD;
+    s->mv_type                     = MV_TYPE_16X16;
     s->current_picture.mb_type[xy] = MB_TYPE_16x16 | MB_TYPE_L0;
-    s->mv[0][0][0] = h->current_mv_x * 2;//gets divided by 2 in motion compensation
-    s->mv[0][0][1] = h->current_mv_y * 2;
+    s->mv[0][0][0]                 = h->current_mv_x * 2; // gets divided by 2 in motion compensation
+    s->mv[0][0][1]                 = h->current_mv_y * 2;
 
 intra:
     /* decode each block */
-    if(s->mb_intra || HAS_CBP(h->mtype)){
+    if (s->mb_intra || HAS_CBP(h->mtype)) {
         s->dsp.clear_blocks(s->block[0]);
         for (i = 0; i < 6; i++) {
-            if (h261_decode_block(h, s->block[i], i, cbp&32) < 0){
+            if (h261_decode_block(h, s->block[i], i, cbp & 32) < 0)
                 return SLICE_ERROR;
-            }
-            cbp+=cbp;
+            cbp += cbp;
         }
-    }else{
+    } else {
         for (i = 0; i < 6; i++)
-            s->block_last_index[i]= -1;
+            s->block_last_index[i] = -1;
     }
 
     ff_MPV_decode_mb(s, s->block);
@@ -355,81 +357,87 @@ intra:
  * Decode a macroblock.
  * @return <0 if an error occurred
  */
-static int h261_decode_block(H261Context * h, int16_t * block,
-                             int n, int coded)
+static int h261_decode_block(H261Context *h, int16_t *block, int n, int coded)
 {
-    MpegEncContext * const s = &h->s;
+    MpegEncContext *const s = &h->s;
     int code, level, i, j, run;
     RLTable *rl = &h261_rl_tcoeff;
     const uint8_t *scan_table;
 
-    // For the variable length encoding there are two code tables, one being used for
-    // the first transmitted LEVEL in INTER, INTER+MC and INTER+MC+FIL blocks, the second
-    // for all other LEVELs except the first one in INTRA blocks which is fixed length
-    // coded with 8 bits.
-    // NOTE: the two code tables only differ in one VLC so we handle that manually.
+    /* For the variable length encoding there are two code tables, one being
+     * used for the first transmitted LEVEL in INTER, INTER + MC and
+     * INTER + MC + FIL blocks, the second for all other LEVELs except the
+     * first one in INTRA blocks which is fixed length coded with 8 bits.
+     * NOTE: The two code tables only differ in one VLC so we handle that
+     * manually. */
     scan_table = s->intra_scantable.permutated;
-    if (s->mb_intra){
+    if (s->mb_intra) {
         /* DC coef */
         level = get_bits(&s->gb, 8);
         // 0 (00000000b) and -128 (10000000b) are FORBIDDEN
-        if((level&0x7F) == 0){
-            av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n", level, s->mb_x, s->mb_y);
+        if ((level & 0x7F) == 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "illegal dc %d at %d %d\n",
+                   level, s->mb_x, s->mb_y);
             return -1;
         }
-        // The code 1000 0000 is not used, the reconstruction level of 1024 being coded as 1111 1111.
+        /* The code 1000 0000 is not used, the reconstruction level of 1024
+         * being coded as 1111 1111. */
         if (level == 255)
             level = 128;
         block[0] = level;
-        i = 1;
-    }else if(coded){
+        i        = 1;
+    } else if (coded) {
         // Run  Level   Code
-        // EOB                  Not possible for first level when cbp is available (that's why the table is different)
-        // 0    1               1s
-        // *    *               0*
+        // EOB          Not possible for first level when cbp is available (that's why the table is different)
+        // 0    1       1s
+        // *    *       0*
         int check = show_bits(&s->gb, 2);
         i = 0;
-        if ( check & 0x2 ){
+        if (check & 0x2) {
             skip_bits(&s->gb, 2);
-            block[0] = ( check & 0x1 ) ? -1 : 1;
-            i = 1;
+            block[0] = (check & 0x1) ? -1 : 1;
+            i        = 1;
         }
-    }else{
+    } else {
         i = 0;
     }
-    if(!coded){
+    if (!coded) {
         s->block_last_index[n] = i - 1;
         return 0;
     }
-    for(;;){
+    for (;;) {
         code = get_vlc2(&s->gb, rl->vlc.table, TCOEFF_VLC_BITS, 2);
-        if (code < 0){
-            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n", s->mb_x, s->mb_y);
+        if (code < 0) {
+            av_log(s->avctx, AV_LOG_ERROR, "illegal ac vlc code at %dx%d\n",
+                   s->mb_x, s->mb_y);
             return -1;
         }
         if (code == rl->n) {
             /* escape */
-            // The remaining combinations of (run, level) are encoded with a 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits level.
-            run = get_bits(&s->gb, 6);
+            /* The remaining combinations of (run, level) are encoded with a
+             * 20-bit word consisting of 6 bits escape, 6 bits run and 8 bits
+             * level. */
+            run   = get_bits(&s->gb, 6);
             level = get_sbits(&s->gb, 8);
-        }else if(code == 0){
+        } else if (code == 0) {
             break;
-        }else{
-            run = rl->table_run[code];
+        } else {
+            run   = rl->table_run[code];
             level = rl->table_level[code];
             if (get_bits1(&s->gb))
                 level = -level;
         }
         i += run;
-        if (i >= 64){
-            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n", s->mb_x, s->mb_y);
+        if (i >= 64) {
+            av_log(s->avctx, AV_LOG_ERROR, "run overflow at %dx%d\n",
+                   s->mb_x, s->mb_y);
             return -1;
         }
-        j = scan_table[i];
+        j        = scan_table[i];
         block[j] = level;
         i++;
     }
-    s->block_last_index[n] = i-1;
+    s->block_last_index[n] = i - 1;
     return 0;
 }
 
@@ -437,33 +445,33 @@ static int h261_decode_block(H261Context * h, int16_t * block,
  * Decode the H.261 picture header.
  * @return <0 if no startcode found
  */
-static int h261_decode_picture_header(H261Context *h){
-    MpegEncContext * const s = &h->s;
+static int h261_decode_picture_header(H261Context *h)
+{
+    MpegEncContext *const s = &h->s;
     int format, i;
-    uint32_t startcode= 0;
+    uint32_t startcode = 0;
 
-    for(i= get_bits_left(&s->gb); i>24; i-=1){
+    for (i = get_bits_left(&s->gb); i > 24; i -= 1) {
         startcode = ((startcode << 1) | get_bits(&s->gb, 1)) & 0x000FFFFF;
 
-        if(startcode == 0x10)
+        if (startcode == 0x10)
             break;
     }
 
-    if (startcode != 0x10){
+    if (startcode != 0x10) {
         av_log(s->avctx, AV_LOG_ERROR, "Bad picture start code\n");
         return -1;
     }
 
     /* temporal reference */
-    i= get_bits(&s->gb, 5); /* picture timestamp */
-    if(i < (s->picture_number&31))
+    i = get_bits(&s->gb, 5); /* picture timestamp */
+    if (i < (s->picture_number & 31))
         i += 32;
-    s->picture_number = (s->picture_number&~31) + i;
+    s->picture_number = (s->picture_number & ~31) + i;
 
-    s->avctx->time_base= (AVRational){1001, 30000};
+    s->avctx->time_base      = (AVRational) { 1001, 30000 };
     s->current_picture.f.pts = s->picture_number;
 
-
     /* PTYPE starts here */
     skip_bits1(&s->gb); /* split screen off */
     skip_bits1(&s->gb); /* camera  off */
@@ -471,16 +479,16 @@ static int h261_decode_picture_header(H261Context *h){
 
     format = get_bits1(&s->gb);
 
-    //only 2 formats possible
-    if (format == 0){//QCIF
-        s->width = 176;
-        s->height = 144;
-        s->mb_width = 11;
+    // only 2 formats possible
+    if (format == 0) { // QCIF
+        s->width     = 176;
+        s->height    = 144;
+        s->mb_width  = 11;
         s->mb_height = 9;
-    }else{//CIF
-        s->width = 352;
-        s->height = 288;
-        s->mb_width = 22;
+    } else { // CIF
+        s->width     = 352;
+        s->height    = 288;
+        s->mb_width  = 22;
         s->mb_height = 18;
     }
 
@@ -490,39 +498,42 @@ static int h261_decode_picture_header(H261Context *h){
     skip_bits1(&s->gb); /* Reserved */
 
     /* PEI */
-    while (get_bits1(&s->gb) != 0){
+    while (get_bits1(&s->gb) != 0)
         skip_bits(&s->gb, 8);
-    }
 
-    // h261 has no I-FRAMES, but if we pass AV_PICTURE_TYPE_I for the first frame, the codec crashes if it does
-    // not contain all I-blocks (e.g. when a packet is lost)
+    /* H.261 has no I-frames, but if we pass AV_PICTURE_TYPE_I for the first
+     * frame, the codec crashes if it does not contain all I-blocks
+     * (e.g. when a packet is lost). */
     s->pict_type = AV_PICTURE_TYPE_P;
 
     h->gob_number = 0;
     return 0;
 }
 
-static int h261_decode_gob(H261Context *h){
-    MpegEncContext * const s = &h->s;
+static int h261_decode_gob(H261Context *h)
+{
+    MpegEncContext *const s = &h->s;
 
     ff_set_qscale(s, s->qscale);
 
     /* decode mb's */
-    while(h->current_mba <= MBA_STUFFING)
-    {
+    while (h->current_mba <= MBA_STUFFING) {
         int ret;
         /* DCT & quantize */
-        ret= h261_decode_mb(h);
-        if(ret<0){
-            if(ret==SLICE_END){
+        ret = h261_decode_mb(h);
+        if (ret < 0) {
+            if (ret == SLICE_END) {
                 h261_decode_mb_skipped(h, h->current_mba, 33);
                 return 0;
             }
-            av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n", s->mb_x + s->mb_y*s->mb_stride);
+            av_log(s->avctx, AV_LOG_ERROR, "Error at MB: %d\n",
+                   s->mb_x + s->mb_y * s->mb_stride);
             return -1;
         }
 
-        h261_decode_mb_skipped(h, h->current_mba-h->mba_diff, h->current_mba-1);
+        h261_decode_mb_skipped(h,
+                               h->current_mba - h->mba_diff,
+                               h->current_mba - 1);
     }
 
     return -1;
@@ -531,62 +542,64 @@ static int h261_decode_gob(H261Context *h){
 /**
  * returns the number of bytes consumed for building the current frame
  */
-static int get_consumed_bytes(MpegEncContext *s, int buf_size){
-    int pos= get_bits_count(&s->gb)>>3;
-    if(pos==0) pos=1; //avoid infinite loops (i doubt that is needed but ...)
-    if(pos+10>buf_size) pos=buf_size; // oops ;)
+static int get_consumed_bytes(MpegEncContext *s, int buf_size)
+{
+    int pos = get_bits_count(&s->gb) >> 3;
+    if (pos == 0)
+        pos = 1;      // avoid infinite loops (i doubt that is needed but ...)
+    if (pos + 10 > buf_size)
+        pos = buf_size;               // oops ;)
 
     return pos;
 }
 
-static int h261_decode_frame(AVCodecContext *avctx,
-                             void *data, int *got_frame,
-                             AVPacket *avpkt)
+static int h261_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame, AVPacket *avpkt)
 {
     const uint8_t *buf = avpkt->data;
-    int buf_size = avpkt->size;
-    H261Context *h= avctx->priv_data;
-    MpegEncContext *s = &h->s;
+    int buf_size       = avpkt->size;
+    H261Context *h     = avctx->priv_data;
+    MpegEncContext *s  = &h->s;
     int ret;
     AVFrame *pict = data;
 
     av_dlog(avctx, "*****frame %d size=%d\n", avctx->frame_number, buf_size);
     av_dlog(avctx, "bytes=%x %x %x %x\n", buf[0], buf[1], buf[2], buf[3]);
-    s->flags= avctx->flags;
-    s->flags2= avctx->flags2;
+    s->flags  = avctx->flags;
+    s->flags2 = avctx->flags2;
 
-    h->gob_start_code_skipped=0;
+    h->gob_start_code_skipped = 0;
 
 retry:
+    init_get_bits(&s->gb, buf, buf_size * 8);
 
-    init_get_bits(&s->gb, buf, buf_size*8);
-
-    if(!s->context_initialized){
-        if (ff_MPV_common_init(s) < 0) //we need the idct permutaton for reading a custom matrix
+    if (!s->context_initialized)
+        // we need the IDCT permutaton for reading a custom matrix
+        if (ff_MPV_common_init(s) < 0)
             return -1;
-    }
 
-    //we need to set current_picture_ptr before reading the header, otherwise we cannot store anyting im there
+    /* We need to set current_picture_ptr before reading the header,
+     * otherwise we cannot store anything in there. */
     if (s->current_picture_ptr == NULL || s->current_picture_ptr->f.data[0]) {
-        int i= ff_find_unused_picture(s, 0);
+        int i = ff_find_unused_picture(s, 0);
         if (i < 0)
             return i;
-        s->current_picture_ptr= &s->picture[i];
+        s->current_picture_ptr = &s->picture[i];
     }
 
     ret = h261_decode_picture_header(h);
 
     /* skip if the header was thrashed */
-    if (ret < 0){
+    if (ret < 0) {
         av_log(s->avctx, AV_LOG_ERROR, "header damaged\n");
         return -1;
     }
 
-    if (s->width != avctx->coded_width || s->height != avctx->coded_height){
-        ParseContext pc= s->parse_context; //FIXME move this demuxing hack to libavformat
-        s->parse_context.buffer=0;
+    if (s->width != avctx->coded_width || s->height != avctx->coded_height) {
+        ParseContext pc = s->parse_context; // FIXME move this demuxing hack to libavformat
+        s->parse_context.buffer = 0;
         ff_MPV_common_end(s);
-        s->parse_context= pc;
+        s->parse_context = pc;
     }
     if (!s->context_initialized) {
         avcodec_set_dimensions(avctx, s->width, s->height);
@@ -598,29 +611,29 @@ retry:
     s->current_picture.f.pict_type = s->pict_type;
     s->current_picture.f.key_frame = s->pict_type == AV_PICTURE_TYPE_I;
 
-    if(  (avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type==AV_PICTURE_TYPE_B)
-       ||(avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type!=AV_PICTURE_TYPE_I)
-       || avctx->skip_frame >= AVDISCARD_ALL)
+    if ((avctx->skip_frame >= AVDISCARD_NONREF && s->pict_type == AV_PICTURE_TYPE_B) ||
+        (avctx->skip_frame >= AVDISCARD_NONKEY && s->pict_type != AV_PICTURE_TYPE_I) ||
+         avctx->skip_frame >= AVDISCARD_ALL)
         return get_consumed_bytes(s, buf_size);
 
-    if(ff_MPV_frame_start(s, avctx) < 0)
+    if (ff_MPV_frame_start(s, avctx) < 0)
         return -1;
 
     ff_mpeg_er_frame_start(s);
 
     /* decode each macroblock */
-    s->mb_x=0;
-    s->mb_y=0;
+    s->mb_x = 0;
+    s->mb_y = 0;
 
-    while(h->gob_number < (s->mb_height==18 ? 12 : 5)){
-        if(ff_h261_resync(h)<0)
+    while (h->gob_number < (s->mb_height == 18 ? 12 : 5)) {
+        if (ff_h261_resync(h) < 0)
             break;
         h261_decode_gob(h);
     }
     ff_MPV_frame_end(s);
 
-assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
-assert(s->current_picture.f.pict_type == s->pict_type);
+    assert(s->current_picture.f.pict_type == s->current_picture_ptr->f.pict_type);
+    assert(s->current_picture.f.pict_type == s->pict_type);
 
     if ((ret = av_frame_ref(pict, &s->current_picture_ptr->f)) < 0)
         return ret;
@@ -633,7 +646,7 @@ assert(s->current_picture.f.pict_type == s->pict_type);
 
 static av_cold int h261_decode_end(AVCodecContext *avctx)
 {
-    H261Context *h= avctx->priv_data;
+    H261Context *h    = avctx->priv_data;
     MpegEncContext *s = &h->s;
 
     ff_MPV_common_end(s);
diff --git a/libavcodec/h261enc.c b/libavcodec/h261enc.c
index 07094136e7..f67d31344a 100644
--- a/libavcodec/h261enc.c
+++ b/libavcodec/h261enc.c
@@ -31,10 +31,11 @@
 #include "h261.h"
 #include "h261data.h"
 
-static void h261_encode_block(H261Context * h, int16_t * block,
+static void h261_encode_block(H261Context *h, int16_t *block,
                               int n);
 
-int ff_h261_get_picture_format(int width, int height){
+int ff_h261_get_picture_format(int width, int height)
+{
     // QCIF
     if (width == 176 && height == 144)
         return 0;
@@ -46,8 +47,9 @@ int ff_h261_get_picture_format(int width, int height){
         return -1;
 }
 
-void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
-    H261Context * h = (H261Context *) s;
+void ff_h261_encode_picture_header(MpegEncContext *s, int picture_number)
+{
+    H261Context *h = (H261Context *)s;
     int format, temp_ref;
 
     avpriv_align_put_bits(&s->pb);
@@ -57,8 +59,8 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
 
     put_bits(&s->pb, 20, 0x10); /* PSC */
 
-    temp_ref= s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
-                         (1001 * (int64_t)s->avctx->time_base.den); //FIXME maybe this should use a timestamp
+    temp_ref = s->picture_number * (int64_t)30000 * s->avctx->time_base.num /
+               (1001 * (int64_t)s->avctx->time_base.den);   // FIXME maybe this should use a timestamp
     put_sbits(&s->pb, 5, temp_ref); /* TemporalReference */
 
     put_bits(&s->pb, 1, 0); /* split screen off */
@@ -73,7 +75,7 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
     put_bits(&s->pb, 1, 0); /* reserved */
 
     put_bits(&s->pb, 1, 0); /* no PEI */
-    if(format == 0)
+    if (format == 0)
         h->gob_number = -1;
     else
         h->gob_number = 0;
@@ -83,78 +85,80 @@ void ff_h261_encode_picture_header(MpegEncContext * s, int picture_number){
 /**
  * Encode a group of blocks header.
  */
-static void h261_encode_gob_header(MpegEncContext * s, int mb_line){
-    H261Context * h = (H261Context *)s;
-    if(ff_h261_get_picture_format(s->width, s->height) == 0){
-        h->gob_number+=2; // QCIF
-    }
-    else{
-        h->gob_number++; // CIF
+static void h261_encode_gob_header(MpegEncContext *s, int mb_line)
+{
+    H261Context *h = (H261Context *)s;
+    if (ff_h261_get_picture_format(s->width, s->height) == 0) {
+        h->gob_number += 2; // QCIF
+    } else {
+        h->gob_number++;    // CIF
     }
-    put_bits(&s->pb, 16, 1); /* GBSC */
+    put_bits(&s->pb, 16, 1);            /* GBSC */
     put_bits(&s->pb, 4, h->gob_number); /* GN */
-    put_bits(&s->pb, 5, s->qscale); /* GQUANT */
-    put_bits(&s->pb, 1, 0); /* no GEI */
-    h->current_mba = 0;
+    put_bits(&s->pb, 5, s->qscale);     /* GQUANT */
+    put_bits(&s->pb, 1, 0);             /* no GEI */
+    h->current_mba  = 0;
     h->previous_mba = 0;
-    h->current_mv_x=0;
-    h->current_mv_y=0;
+    h->current_mv_x = 0;
+    h->current_mv_y = 0;
 }
 
-void ff_h261_reorder_mb_index(MpegEncContext* s){
-    int index= s->mb_x + s->mb_y*s->mb_width;
+void ff_h261_reorder_mb_index(MpegEncContext *s)
+{
+    int index = s->mb_x + s->mb_y * s->mb_width;
 
-    if(index % 33 == 0)
-        h261_encode_gob_header(s,0);
+    if (index % 33 == 0)
+        h261_encode_gob_header(s, 0);
 
     /* for CIF the GOB's are fragmented in the middle of a scanline
-       that's why we need to adjust the x and y index of the macroblocks */
-    if(ff_h261_get_picture_format(s->width,s->height) == 1){ // CIF
-        s->mb_x =     index % 11 ; index /= 11;
-        s->mb_y =     index %  3 ; index /=  3;
-        s->mb_x+= 11*(index %  2); index /=  2;
-        s->mb_y+=  3*index;
+     * that's why we need to adjust the x and y index of the macroblocks */
+    if (ff_h261_get_picture_format(s->width, s->height) == 1) { // CIF
+        s->mb_x  = index % 11;
+        index   /= 11;
+        s->mb_y  = index % 3;
+        index   /= 3;
+        s->mb_x += 11 * (index % 2);
+        index   /= 2;
+        s->mb_y += 3 * index;
 
         ff_init_block_index(s);
         ff_update_block_index(s);
     }
 }
 
-static void h261_encode_motion(H261Context * h, int val){
-    MpegEncContext * const s = &h->s;
+static void h261_encode_motion(H261Context *h, int val)
+{
+    MpegEncContext *const s = &h->s;
     int sign, code;
-    if(val==0){
+    if (val == 0) {
         code = 0;
-        put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
-    }
-    else{
-        if(val > 15)
-            val -=32;
-        if(val < -16)
-            val+=32;
+        put_bits(&s->pb, h261_mv_tab[code][1], h261_mv_tab[code][0]);
+    } else {
+        if (val > 15)
+            val -= 32;
+        if (val < -16)
+            val += 32;
         sign = val < 0;
         code = sign ? -val : val;
-        put_bits(&s->pb,h261_mv_tab[code][1],h261_mv_tab[code][0]);
-        put_bits(&s->pb,1,sign);
+        put_bits(&s->pb, h261_mv_tab[code][1], h261_mv_tab[code][0]);
+        put_bits(&s->pb, 1, sign);
     }
 }
 
-static inline int get_cbp(MpegEncContext * s,
-                      int16_t block[6][64])
+static inline int get_cbp(MpegEncContext *s, int16_t block[6][64])
 {
     int i, cbp;
-    cbp= 0;
-    for (i = 0; i < 6; i++) {
+    cbp = 0;
+    for (i = 0; i < 6; i++)
         if (s->block_last_index[i] >= 0)
             cbp |= 1 << (5 - i);
-    }
     return cbp;
 }
-void ff_h261_encode_mb(MpegEncContext * s,
-         int16_t block[6][64],
-         int motion_x, int motion_y)
+
+void ff_h261_encode_mb(MpegEncContext *s, int16_t block[6][64],
+                       int motion_x, int motion_y)
 {
-    H261Context * h = (H261Context *)s;
+    H261Context *h = (H261Context *)s;
     int mvd, mv_diff_x, mv_diff_y, i, cbp;
     cbp = 63; // avoid warning
     mvd = 0;
@@ -162,77 +166,79 @@ void ff_h261_encode_mb(MpegEncContext * s,
     h->current_mba++;
     h->mtype = 0;
 
-    if (!s->mb_intra){
+    if (!s->mb_intra) {
         /* compute cbp */
-        cbp= get_cbp(s, block);
+        cbp = get_cbp(s, block);
 
         /* mvd indicates if this block is motion compensated */
         mvd = motion_x | motion_y;
 
-        if((cbp | mvd | s->dquant ) == 0) {
+        if ((cbp | mvd | s->dquant) == 0) {
             /* skip macroblock */
             s->skip_count++;
-            h->current_mv_x=0;
-            h->current_mv_y=0;
+            h->current_mv_x = 0;
+            h->current_mv_y = 0;
             return;
         }
     }
 
     /* MB is not skipped, encode MBA */
-    put_bits(&s->pb, h261_mba_bits[(h->current_mba-h->previous_mba)-1], h261_mba_code[(h->current_mba-h->previous_mba)-1]);
+    put_bits(&s->pb, h261_mba_bits[(h->current_mba - h->previous_mba) - 1],
+             h261_mba_code[(h->current_mba - h->previous_mba) - 1]);
 
     /* calculate MTYPE */
-    if(!s->mb_intra){
+    if (!s->mb_intra) {
         h->mtype++;
 
-        if(mvd || s->loop_filter)
-            h->mtype+=3;
-        if(s->loop_filter)
-            h->mtype+=3;
-        if(cbp || s->dquant)
+        if (mvd || s->loop_filter)
+            h->mtype += 3;
+        if (s->loop_filter)
+            h->mtype += 3;
+        if (cbp || s->dquant)
             h->mtype++;
         assert(h->mtype > 1);
     }
 
-    if(s->dquant)
+    if (s->dquant)
         h->mtype++;
 
     put_bits(&s->pb, h261_mtype_bits[h->mtype], h261_mtype_code[h->mtype]);
 
     h->mtype = h261_mtype_map[h->mtype];
 
-    if(IS_QUANT(h->mtype)){
-        ff_set_qscale(s,s->qscale+s->dquant);
+    if (IS_QUANT(h->mtype)) {
+        ff_set_qscale(s, s->qscale + s->dquant);
         put_bits(&s->pb, 5, s->qscale);
     }
 
-    if(IS_16X16(h->mtype)){
-        mv_diff_x = (motion_x >> 1) - h->current_mv_x;
-        mv_diff_y = (motion_y >> 1) - h->current_mv_y;
+    if (IS_16X16(h->mtype)) {
+        mv_diff_x       = (motion_x >> 1) - h->current_mv_x;
+        mv_diff_y       = (motion_y >> 1) - h->current_mv_y;
         h->current_mv_x = (motion_x >> 1);
         h->current_mv_y = (motion_y >> 1);
-        h261_encode_motion(h,mv_diff_x);
-        h261_encode_motion(h,mv_diff_y);
+        h261_encode_motion(h, mv_diff_x);
+        h261_encode_motion(h, mv_diff_y);
     }
 
     h->previous_mba = h->current_mba;
 
-    if(HAS_CBP(h->mtype)){
-        assert(cbp>0);
-        put_bits(&s->pb,h261_cbp_tab[cbp-1][1],h261_cbp_tab[cbp-1][0]);
+    if (HAS_CBP(h->mtype)) {
+        assert(cbp > 0);
+        put_bits(&s->pb, h261_cbp_tab[cbp - 1][1], h261_cbp_tab[cbp - 1][0]);
     }
-    for(i=0; i<6; i++) {
+    for (i = 0; i < 6; i++)
         /* encode each block */
         h261_encode_block(h, block[i], i);
-    }
 
-    if ( ( h->current_mba == 11 ) || ( h->current_mba == 22 ) || ( h->current_mba == 33 ) || ( !IS_16X16 ( h->mtype ) )){
-        h->current_mv_x=0;
-        h->current_mv_y=0;
+    if ((h->current_mba == 11) || (h->current_mba == 22) ||
+        (h->current_mba == 33) || (!IS_16X16(h->mtype))) {
+        h->current_mv_x = 0;
+        h->current_mv_y = 0;
     }
 }
 
-void ff_h261_encode_init(MpegEncContext *s){
+void ff_h261_encode_init(MpegEncContext *s)
+{
     static int done = 0;
 
     if (!done) {
@@ -240,20 +246,20 @@ void ff_h261_encode_init(MpegEncContext *s){
         ff_init_rl(&h261_rl_tcoeff, ff_h261_rl_table_store);
     }
 
-    s->min_qcoeff= -127;
-    s->max_qcoeff=  127;
-    s->y_dc_scale_table=
-    s->c_dc_scale_table= ff_mpeg1_dc_scale_table;
+    s->min_qcoeff       = -127;
+    s->max_qcoeff       = 127;
+    s->y_dc_scale_table =
+    s->c_dc_scale_table = ff_mpeg1_dc_scale_table;
 }
 
-
 /**
  * Encode an 8x8 block.
  * @param block the 8x8 block
  * @param n block index (0-3 are luma, 4-5 are chroma)
  */
-static void h261_encode_block(H261Context * h, int16_t * block, int n){
-    MpegEncContext * const s = &h->s;
+static void h261_encode_block(H261Context *h, int16_t *block, int n)
+{
+    MpegEncContext *const s = &h->s;
     int level, run, i, j, last_index, last_non_zero, sign, slevel, code;
     RLTable *rl;
 
@@ -263,12 +269,12 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
         level = block[0];
         /* 255 cannot be represented, so we clamp */
         if (level > 254) {
-            level = 254;
+            level    = 254;
             block[0] = 254;
         }
         /* 0 cannot be represented also */
         else if (level < 1) {
-            level = 1;
+            level    = 1;
             block[0] = 1;
         }
         if (level == 128)
@@ -276,31 +282,33 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
         else
             put_bits(&s->pb, 8, level);
         i = 1;
-    } else if((block[0]==1 || block[0] == -1) && (s->block_last_index[n] > -1)){
-        //special case
-        put_bits(&s->pb,2,block[0]>0 ? 2 : 3 );
+    } else if ((block[0] == 1 || block[0] == -1) &&
+               (s->block_last_index[n] > -1)) {
+        // special case
+        put_bits(&s->pb, 2, block[0] > 0 ? 2 : 3);
         i = 1;
     } else {
         i = 0;
     }
 
     /* AC coefs */
-    last_index = s->block_last_index[n];
+    last_index    = s->block_last_index[n];
     last_non_zero = i - 1;
     for (; i <= last_index; i++) {
-        j = s->intra_scantable.permutated[i];
+        j     = s->intra_scantable.permutated[i];
         level = block[j];
         if (level) {
-            run = i - last_non_zero - 1;
-            sign = 0;
+            run    = i - last_non_zero - 1;
+            sign   = 0;
             slevel = level;
             if (level < 0) {
-                sign = 1;
+                sign  = 1;
                 level = -level;
             }
-            code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/, run, level);
-            if(run==0 && level < 16)
-            code+=1;
+            code = get_rl_index(rl, 0 /*no last in H.261, EOB is used*/,
+                                run, level);
+            if (run == 0 && level < 16)
+                code += 1;
             put_bits(&s->pb, rl->table_vlc[code][1], rl->table_vlc[code][0]);
             if (code == rl->n) {
                 put_bits(&s->pb, 6, run);
@@ -313,9 +321,8 @@ static void h261_encode_block(H261Context * h, int16_t * block, int n){
             last_non_zero = i;
         }
     }
-    if(last_index > -1){
-        put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]);// END OF BLOCK
-    }
+    if (last_index > -1)
+        put_bits(&s->pb, rl->table_vlc[0][1], rl->table_vlc[0][0]); // EOB
 }
 
 FF_MPV_GENERIC_CLASS(h261)
@@ -328,7 +335,8 @@ AVCodec ff_h261_encoder = {
     .init           = ff_MPV_encode_init,
     .encode2        = ff_MPV_encode_picture,
     .close          = ff_MPV_encode_end,
-    .pix_fmts       = (const enum AVPixelFormat[]){ AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE },
+    .pix_fmts       = (const enum AVPixelFormat[]) { AV_PIX_FMT_YUV420P,
+                                                     AV_PIX_FMT_NONE },
     .long_name      = NULL_IF_CONFIG_SMALL("H.261"),
     .priv_class     = &h261_class,
 };