Merge commit 'eda7571ea1a41c835e3a02fa9517e5bc67d7adce'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 02:13:37 +0000 (04:13 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 3 Sep 2014 02:13:37 +0000 (04:13 +0200)
* commit 'eda7571ea1a41c835e3a02fa9517e5bc67d7adce':
  wmv2: K&R formatting cosmetics

Conflicts:
libavcodec/wmv2.c
libavcodec/wmv2dec.c
libavcodec/wmv2enc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/wmv2.c
libavcodec/wmv2.h
libavcodec/wmv2dec.c
libavcodec/wmv2enc.c

diff --combined libavcodec/wmv2.c
@@@ -1,20 -1,20 +1,20 @@@
  /*
 - * Copyright (c) 2002 The Libav Project
 + * Copyright (c) 2002 The FFmpeg Project
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -26,8 -26,9 +26,9 @@@
  #include "wmv2.h"
  
  
- av_cold void ff_wmv2_common_init(Wmv2Context * w){
-     MpegEncContext * const s= &w->s;
+ av_cold void ff_wmv2_common_init(Wmv2Context *w)
+ {
+     MpegEncContext *const s = &w->s;
  
      ff_blockdsp_init(&s->bdsp, s->avctx);
      ff_wmv2dsp_init(&w->wdsp);
      s->idsp.idct     = NULL;
  }
  
- static void wmv2_add_block(Wmv2Context *w, int16_t *block1, uint8_t *dst, int stride, int n){
-     MpegEncContext * const s= &w->s;
-   if (s->block_last_index[n] >= 0) {
-     switch(w->abt_type_table[n]){
-     case 0:
-         w->wdsp.idct_add(dst, stride, block1);
-         break;
-     case 1:
-         ff_simple_idct84_add(dst           , stride, block1);
-         ff_simple_idct84_add(dst + 4*stride, stride, w->abt_block2[n]);
-         s->bdsp.clear_block(w->abt_block2[n]);
-         break;
-     case 2:
-         ff_simple_idct48_add(dst           , stride, block1);
-         ff_simple_idct48_add(dst + 4       , stride, w->abt_block2[n]);
-         s->bdsp.clear_block(w->abt_block2[n]);
-         break;
-     default:
-         av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
+ static void wmv2_add_block(Wmv2Context *w, int16_t *block1,
+                            uint8_t *dst, int stride, int n)
+ {
+     MpegEncContext *const s = &w->s;
+     if (s->block_last_index[n] >= 0) {
+         switch (w->abt_type_table[n]) {
+         case 0:
+             w->wdsp.idct_add(dst, stride, block1);
+             break;
+         case 1:
+             ff_simple_idct84_add(dst, stride, block1);
+             ff_simple_idct84_add(dst + 4 * stride, stride, w->abt_block2[n]);
+             s->bdsp.clear_block(w->abt_block2[n]);
+             break;
+         case 2:
+             ff_simple_idct48_add(dst, stride, block1);
+             ff_simple_idct48_add(dst + 4, stride, w->abt_block2[n]);
+             s->bdsp.clear_block(w->abt_block2[n]);
+             break;
+         default:
+             av_log(s->avctx, AV_LOG_ERROR, "internal error in WMV2 abt\n");
+         }
      }
-   }
  }
  
- void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64], uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr){
-     Wmv2Context * const w= (Wmv2Context*)s;
+ void ff_wmv2_add_mb(MpegEncContext *s, int16_t block1[6][64],
+                     uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr)
+ {
+     Wmv2Context *const w = (Wmv2Context *) s;
  
-     wmv2_add_block(w, block1[0], dest_y                    , s->linesize, 0);
-     wmv2_add_block(w, block1[1], dest_y + 8                , s->linesize, 1);
-     wmv2_add_block(w, block1[2], dest_y +     8*s->linesize, s->linesize, 2);
-     wmv2_add_block(w, block1[3], dest_y + 8 + 8*s->linesize, s->linesize, 3);
+     wmv2_add_block(w, block1[0], dest_y,                       s->linesize, 0);
+     wmv2_add_block(w, block1[1], dest_y + 8,                   s->linesize, 1);
+     wmv2_add_block(w, block1[2], dest_y + 8 * s->linesize,     s->linesize, 2);
+     wmv2_add_block(w, block1[3], dest_y + 8 + 8 * s->linesize, s->linesize, 3);
  
-     if(s->flags&CODEC_FLAG_GRAY) return;
+     if (s->flags & CODEC_FLAG_GRAY)
+         return;
  
-     wmv2_add_block(w, block1[4], dest_cb                   , s->uvlinesize, 4);
-     wmv2_add_block(w, block1[5], dest_cr                   , s->uvlinesize, 5);
+     wmv2_add_block(w, block1[4], dest_cb, s->uvlinesize, 4);
+     wmv2_add_block(w, block1[5], dest_cr, s->uvlinesize, 5);
  }
  
- void ff_mspel_motion(MpegEncContext *s,
-                                uint8_t *dest_y, uint8_t *dest_cb, uint8_t *dest_cr,
-                                uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
-                                int motion_x, int motion_y, int h)
+ void ff_mspel_motion(MpegEncContext *s, uint8_t *dest_y,
+                      uint8_t *dest_cb, uint8_t *dest_cr,
+                      uint8_t **ref_picture, op_pixels_func (*pix_op)[4],
+                      int motion_x, int motion_y, int h)
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
      uint8_t *ptr;
 -    int dxy, offset, mx, my, src_x, src_y, v_edge_pos;
 -    ptrdiff_t linesize, uvlinesize;
 +    int dxy, mx, my, src_x, src_y, v_edge_pos;
 +    ptrdiff_t offset, linesize, uvlinesize;
-     int emu=0;
+     int emu = 0;
  
-     dxy = ((motion_y & 1) << 1) | (motion_x & 1);
-     dxy = 2*dxy + w->hshift;
+     dxy   = ((motion_y & 1) << 1) | (motion_x & 1);
+     dxy   = 2 * dxy + w->hshift;
      src_x = s->mb_x * 16 + (motion_x >> 1);
      src_y = s->mb_y * 16 + (motion_y >> 1);
  
      /* WARNING: do no forget half pels */
      v_edge_pos = s->v_edge_pos;
-     src_x = av_clip(src_x, -16, s->width);
-     src_y = av_clip(src_y, -16, s->height);
+     src_x      = av_clip(src_x, -16, s->width);
+     src_y      = av_clip(src_y, -16, s->height);
  
-     if(src_x<=-16 || src_x >= s->width)
+     if (src_x <= -16 || src_x >= s->width)
          dxy &= ~3;
-     if(src_y<=-16 || src_y >= s->height)
+     if (src_y <= -16 || src_y >= s->height)
          dxy &= ~4;
  
      linesize   = s->linesize;
      uvlinesize = s->uvlinesize;
-     ptr = ref_picture[0] + (src_y * linesize) + src_x;
-     if(src_x<1 || src_y<1 || src_x + 17  >= s->h_edge_pos
-                           || src_y + h+1 >= v_edge_pos){
-         s->vdsp.emulated_edge_mc(s->edge_emu_buffer,
-                                  ptr - 1 - s->linesize,
-                                  s->linesize, s->linesize,
-                                  19, 19,
+     ptr        = ref_picture[0] + (src_y * linesize) + src_x;
+     if (src_x < 1 || src_y < 1 || src_x + 17 >= s->h_edge_pos ||
+         src_y + h + 1 >= v_edge_pos) {
+         s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr - 1 - s->linesize,
+                                  s->linesize, s->linesize, 19, 19,
                                   src_x - 1, src_y - 1,
                                   s->h_edge_pos, s->v_edge_pos);
-         ptr= s->edge_emu_buffer + 1 + s->linesize;
-         emu=1;
+         ptr = s->edge_emu_buffer + 1 + s->linesize;
+         emu = 1;
      }
  
      w->wdsp.put_mspel_pixels_tab[dxy](dest_y,                    ptr,                    linesize);
      w->wdsp.put_mspel_pixels_tab[dxy](dest_y     + 8 * linesize, ptr     + 8 * linesize, linesize);
      w->wdsp.put_mspel_pixels_tab[dxy](dest_y + 8 + 8 * linesize, ptr + 8 + 8 * linesize, linesize);
  
-     if(s->flags&CODEC_FLAG_GRAY) return;
+     if (s->flags & CODEC_FLAG_GRAY)
+         return;
  
 -    if (s->out_format == FMT_H263) {
 -        dxy = 0;
 -        if ((motion_x & 3) != 0)
 -            dxy |= 1;
 -        if ((motion_y & 3) != 0)
 -            dxy |= 2;
 -        mx = motion_x >> 2;
 -        my = motion_y >> 2;
 -    } else {
 -        mx   = motion_x / 2;
 -        my   = motion_y / 2;
 -        dxy  = ((my & 1) << 1) | (mx & 1);
 -        mx >>= 1;
 -        my >>= 1;
 -    }
 +    dxy = 0;
 +    if ((motion_x & 3) != 0)
 +        dxy |= 1;
 +    if ((motion_y & 3) != 0)
 +        dxy |= 2;
 +    mx = motion_x >> 2;
 +    my = motion_y >> 2;
  
      src_x = s->mb_x * 8 + mx;
      src_y = s->mb_y * 8 + my;
      if (src_y == (s->height >> 1))
          dxy &= ~2;
      offset = (src_y * uvlinesize) + src_x;
-     ptr = ref_picture[1] + offset;
-     if(emu){
+     ptr    = ref_picture[1] + offset;
+     if (emu) {
          s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
                                   s->uvlinesize, s->uvlinesize,
                                   9, 9,
                                   src_x, src_y,
                                   s->h_edge_pos >> 1, s->v_edge_pos >> 1);
-         ptr= s->edge_emu_buffer;
+         ptr = s->edge_emu_buffer;
      }
      pix_op[1][dxy](dest_cb, ptr, uvlinesize, h >> 1);
  
      ptr = ref_picture[2] + offset;
-     if(emu){
+     if (emu) {
          s->vdsp.emulated_edge_mc(s->edge_emu_buffer, ptr,
                                   s->uvlinesize, s->uvlinesize,
                                   9, 9,
                                   src_x, src_y,
                                   s->h_edge_pos >> 1, s->v_edge_pos >> 1);
-         ptr= s->edge_emu_buffer;
+         ptr = s->edge_emu_buffer;
      }
      pix_op[1][dxy](dest_cr, ptr, uvlinesize, h >> 1);
  }
diff --combined libavcodec/wmv2.h
@@@ -1,20 -1,20 +1,20 @@@
  /*
 - * Copyright (c) 2002 The Libav Project
 + * Copyright (c) 2002 The FFmpeg Project
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -22,8 -22,8 +22,8 @@@
  #define AVCODEC_WMV2_H
  
  #include "avcodec.h"
- #include "mpegvideo.h"
  #include "intrax8.h"
+ #include "mpegvideo.h"
  #include "wmv2dsp.h"
  
  #define SKIP_TYPE_NONE 0
@@@ -32,7 -32,7 +32,7 @@@
  #define SKIP_TYPE_COL  3
  
  
- typedef struct Wmv2Context{
+ typedef struct Wmv2Context {
      MpegEncContext s;
      IntraX8Context x8;
      WMV2DSPContext wdsp;
@@@ -52,8 -52,8 +52,8 @@@
  
      ScanTable abt_scantable[2];
      DECLARE_ALIGNED(16, int16_t, abt_block2)[6][64];
- }Wmv2Context;
+ } Wmv2Context;
  
- void ff_wmv2_common_init(Wmv2Context * w);
+ void ff_wmv2_common_init(Wmv2Context *w);
  
  #endif /* AVCODEC_WMV2_H */
diff --combined libavcodec/wmv2dec.c
  /*
 - * Copyright (c) 2002 The Libav Project
 + * Copyright (c) 2002 The FFmpeg Project
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "avcodec.h"
- #include "mpegutils.h"
- #include "mpegvideo.h"
  #include "h263.h"
+ #include "intrax8.h"
  #include "mathops.h"
+ #include "mpegutils.h"
+ #include "mpegvideo.h"
  #include "msmpeg4.h"
  #include "msmpeg4data.h"
- #include "intrax8.h"
  #include "wmv2.h"
  
  
- static void parse_mb_skip(Wmv2Context * w){
+ static void parse_mb_skip(Wmv2Context *w)
+ {
      int mb_x, mb_y;
-     MpegEncContext * const s= &w->s;
-     uint32_t * const mb_type = s->current_picture_ptr->mb_type;
+     MpegEncContext *const s = &w->s;
+     uint32_t *const mb_type = s->current_picture_ptr->mb_type;
  
-     w->skip_type= get_bits(&s->gb, 2);
-     switch(w->skip_type){
+     w->skip_type = get_bits(&s->gb, 2);
+     switch (w->skip_type) {
      case SKIP_TYPE_NONE:
-         for(mb_y=0; mb_y<s->mb_height; mb_y++){
-             for(mb_x=0; mb_x<s->mb_width; mb_x++){
-                 mb_type[mb_y*s->mb_stride + mb_x]= MB_TYPE_16x16 | MB_TYPE_L0;
-             }
-         }
+         for (mb_y = 0; mb_y < s->mb_height; mb_y++)
+             for (mb_x = 0; mb_x < s->mb_width; mb_x++)
+                 mb_type[mb_y * s->mb_stride + mb_x] =
+                     MB_TYPE_16x16 | MB_TYPE_L0;
          break;
      case SKIP_TYPE_MPEG:
-         for(mb_y=0; mb_y<s->mb_height; mb_y++){
-             for(mb_x=0; mb_x<s->mb_width; mb_x++){
-                 mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
-             }
-         }
+         for (mb_y = 0; mb_y < s->mb_height; mb_y++)
+             for (mb_x = 0; mb_x < s->mb_width; mb_x++)
+                 mb_type[mb_y * s->mb_stride + mb_x] =
+                     (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
          break;
      case SKIP_TYPE_ROW:
-         for(mb_y=0; mb_y<s->mb_height; mb_y++){
-             if(get_bits1(&s->gb)){
-                 for(mb_x=0; mb_x<s->mb_width; mb_x++){
-                     mb_type[mb_y*s->mb_stride + mb_x]=  MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
-                 }
-             }else{
-                 for(mb_x=0; mb_x<s->mb_width; mb_x++){
-                     mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
-                 }
+         for (mb_y = 0; mb_y < s->mb_height; mb_y++) {
+             if (get_bits1(&s->gb)) {
+                 for (mb_x = 0; mb_x < s->mb_width; mb_x++)
+                     mb_type[mb_y * s->mb_stride + mb_x] =
+                         MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
+             } else {
+                 for (mb_x = 0; mb_x < s->mb_width; mb_x++)
+                     mb_type[mb_y * s->mb_stride + mb_x] =
+                         (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
              }
          }
          break;
      case SKIP_TYPE_COL:
-         for(mb_x=0; mb_x<s->mb_width; mb_x++){
-             if(get_bits1(&s->gb)){
-                 for(mb_y=0; mb_y<s->mb_height; mb_y++){
-                     mb_type[mb_y*s->mb_stride + mb_x]=  MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
-                 }
-             }else{
-                 for(mb_y=0; mb_y<s->mb_height; mb_y++){
-                     mb_type[mb_y*s->mb_stride + mb_x]= (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
-                 }
+         for (mb_x = 0; mb_x < s->mb_width; mb_x++) {
+             if (get_bits1(&s->gb)) {
+                 for (mb_y = 0; mb_y < s->mb_height; mb_y++)
+                     mb_type[mb_y * s->mb_stride + mb_x] =
+                         MB_TYPE_SKIP | MB_TYPE_16x16 | MB_TYPE_L0;
+             } else {
+                 for (mb_y = 0; mb_y < s->mb_height; mb_y++)
+                     mb_type[mb_y * s->mb_stride + mb_x] =
+                         (get_bits1(&s->gb) ? MB_TYPE_SKIP : 0) | MB_TYPE_16x16 | MB_TYPE_L0;
              }
          }
          break;
      }
  }
  
- static int decode_ext_header(Wmv2Context *w){
-     MpegEncContext * const s= &w->s;
+ static int decode_ext_header(Wmv2Context *w)
+ {
+     MpegEncContext *const s = &w->s;
      GetBitContext gb;
      int fps;
      int code;
  
-     if(s->avctx->extradata_size<4) return -1;
+     if (s->avctx->extradata_size < 4)
+         return -1;
  
      init_get_bits(&gb, s->avctx->extradata, 32);
  
-     fps                = get_bits(&gb, 5);
-     s->bit_rate        = get_bits(&gb, 11)*1024;
-     w->mspel_bit       = get_bits1(&gb);
-     s->loop_filter     = get_bits1(&gb);
-     w->abt_flag        = get_bits1(&gb);
-     w->j_type_bit      = get_bits1(&gb);
-     w->top_left_mv_flag= get_bits1(&gb);
-     w->per_mb_rl_bit   = get_bits1(&gb);
-     code               = get_bits(&gb, 3);
-     if(code==0) return -1;
+     fps                 = get_bits(&gb, 5);
+     s->bit_rate         = get_bits(&gb, 11) * 1024;
+     w->mspel_bit        = get_bits1(&gb);
+     s->loop_filter      = get_bits1(&gb);
+     w->abt_flag         = get_bits1(&gb);
+     w->j_type_bit       = get_bits1(&gb);
+     w->top_left_mv_flag = get_bits1(&gb);
+     w->per_mb_rl_bit    = get_bits1(&gb);
+     code                = get_bits(&gb, 3);
+     if (code == 0)
+         return -1;
  
      s->slice_height = s->mb_height / code;
  
-     if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-         av_log(s->avctx, AV_LOG_DEBUG, "fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, slices:%d\n",
-         fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit, w->top_left_mv_flag, w->per_mb_rl_bit, code, s->loop_filter,
-         code);
-     }
+     if (s->avctx->debug & FF_DEBUG_PICT_INFO)
+         av_log(s->avctx, AV_LOG_DEBUG,
+                "fps:%d, br:%d, qpbit:%d, abt_flag:%d, j_type_bit:%d, "
+                "tl_mv_flag:%d, mbrl_bit:%d, code:%d, loop_filter:%d, "
+                "slices:%d\n",
+                fps, s->bit_rate, w->mspel_bit, w->abt_flag, w->j_type_bit,
+                w->top_left_mv_flag, w->per_mb_rl_bit, code, s->loop_filter,
+                code);
      return 0;
  }
  
- int ff_wmv2_decode_picture_header(MpegEncContext * s)
+ int ff_wmv2_decode_picture_header(MpegEncContext *s)
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
      int code;
  
-     if(s->picture_number==0)
+     if (s->picture_number == 0)
          decode_ext_header(w);
  
      s->pict_type = get_bits1(&s->gb) + 1;
-     if(s->pict_type == AV_PICTURE_TYPE_I){
+     if (s->pict_type == AV_PICTURE_TYPE_I) {
          code = get_bits(&s->gb, 7);
          av_log(s->avctx, AV_LOG_DEBUG, "I7:%X/\n", code);
      }
-     s->chroma_qscale= s->qscale = get_bits(&s->gb, 5);
-     if(s->qscale <= 0)
-        return -1;
+     s->chroma_qscale = s->qscale = get_bits(&s->gb, 5);
+     if (s->qscale <= 0)
+         return -1;
  
      return 0;
  }
  
- int ff_wmv2_decode_secondary_picture_header(MpegEncContext * s)
+ int ff_wmv2_decode_secondary_picture_header(MpegEncContext *s)
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
  
      if (s->pict_type == AV_PICTURE_TYPE_I) {
-         if(w->j_type_bit) w->j_type= get_bits1(&s->gb);
-         else              w->j_type= 0; //FIXME check
-         if(!w->j_type){
-             if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
-             else                 s->per_mb_rl_table= 0;
-             if(!s->per_mb_rl_table){
+         if (w->j_type_bit)
+             w->j_type = get_bits1(&s->gb);
+         else
+             w->j_type = 0; // FIXME check
+         if (!w->j_type) {
+             if (w->per_mb_rl_bit)
+                 s->per_mb_rl_table = get_bits1(&s->gb);
+             else
+                 s->per_mb_rl_table = 0;
+             if (!s->per_mb_rl_table) {
                  s->rl_chroma_table_index = decode012(&s->gb);
-                 s->rl_table_index = decode012(&s->gb);
+                 s->rl_table_index        = decode012(&s->gb);
              }
  
              s->dc_table_index = get_bits1(&s->gb);
          }
-         s->inter_intra_pred= 0;
-         s->no_rounding = 1;
-         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-             av_log(s->avctx, AV_LOG_DEBUG, "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
-                 s->qscale,
-                 s->rl_chroma_table_index,
-                 s->rl_table_index,
-                 s->dc_table_index,
-                 s->per_mb_rl_table,
-                 w->j_type);
+         s->inter_intra_pred = 0;
+         s->no_rounding      = 1;
+         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
+             av_log(s->avctx, AV_LOG_DEBUG,
+                    "qscale:%d rlc:%d rl:%d dc:%d mbrl:%d j_type:%d \n",
+                    s->qscale, s->rl_chroma_table_index, s->rl_table_index,
+                    s->dc_table_index, s->per_mb_rl_table, w->j_type);
          }
-     }else{
+     } else {
          int cbp_index;
-         w->j_type=0;
+         w->j_type = 0;
  
          parse_mb_skip(w);
-         cbp_index= decode012(&s->gb);
-         if(s->qscale <= 10){
-             int map[3]= {0,2,1};
-             w->cbp_table_index= map[cbp_index];
-         }else if(s->qscale <= 20){
-             int map[3]= {1,0,2};
-             w->cbp_table_index= map[cbp_index];
-         }else{
-             int map[3]= {2,1,0};
-             w->cbp_table_index= map[cbp_index];
+         cbp_index = decode012(&s->gb);
+         if (s->qscale <= 10) {
+             int map[3]         = { 0, 2, 1 };
+             w->cbp_table_index = map[cbp_index];
+         } else if (s->qscale <= 20) {
+             int map[3]         = { 1, 0, 2 };
+             w->cbp_table_index = map[cbp_index];
+         } else {
+             int map[3]         = {2,1,0};
+             w->cbp_table_index = map[cbp_index];
          }
  
-         if(w->mspel_bit) s->mspel= get_bits1(&s->gb);
-         else             s->mspel= 0; //FIXME check
+         if (w->mspel_bit)
+             s->mspel = get_bits1(&s->gb);
+         else
+             s->mspel = 0; // FIXME check
  
-         if(w->abt_flag){
-             w->per_mb_abt= get_bits1(&s->gb)^1;
-             if(!w->per_mb_abt){
-                 w->abt_type= decode012(&s->gb);
-             }
+         if (w->abt_flag) {
+             w->per_mb_abt = get_bits1(&s->gb) ^ 1;
+             if (!w->per_mb_abt)
+                 w->abt_type = decode012(&s->gb);
          }
  
-         if(w->per_mb_rl_bit) s->per_mb_rl_table= get_bits1(&s->gb);
-         else                 s->per_mb_rl_table= 0;
+         if (w->per_mb_rl_bit)
+             s->per_mb_rl_table = get_bits1(&s->gb);
+         else
+             s->per_mb_rl_table = 0;
  
-         if(!s->per_mb_rl_table){
-             s->rl_table_index = decode012(&s->gb);
+         if (!s->per_mb_rl_table) {
+             s->rl_table_index        = decode012(&s->gb);
              s->rl_chroma_table_index = s->rl_table_index;
          }
  
-         s->dc_table_index = get_bits1(&s->gb);
-         s->mv_table_index = get_bits1(&s->gb);
-         s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
-         s->no_rounding ^= 1;
-         if(s->avctx->debug&FF_DEBUG_PICT_INFO){
-             av_log(s->avctx, AV_LOG_DEBUG, "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n",
-                 s->rl_table_index,
-                 s->rl_chroma_table_index,
-                 s->dc_table_index,
-                 s->mv_table_index,
-                 s->per_mb_rl_table,
-                 s->qscale,
-                 s->mspel,
-                 w->per_mb_abt,
-                 w->abt_type,
-                 w->cbp_table_index,
-                 s->inter_intra_pred);
+         s->dc_table_index   = get_bits1(&s->gb);
+         s->mv_table_index   = get_bits1(&s->gb);
+         s->inter_intra_pred = 0; // (s->width * s->height < 320 * 240 && s->bit_rate <= II_BITRATE);
+         s->no_rounding     ^= 1;
+         if (s->avctx->debug & FF_DEBUG_PICT_INFO) {
+             av_log(s->avctx, AV_LOG_DEBUG,
+                    "rl:%d rlc:%d dc:%d mv:%d mbrl:%d qp:%d mspel:%d "
+                    "per_mb_abt:%d abt_type:%d cbp:%d ii:%d\n",
+                    s->rl_table_index, s->rl_chroma_table_index,
+                    s->dc_table_index, s->mv_table_index,
+                    s->per_mb_rl_table, s->qscale, s->mspel,
+                    w->per_mb_abt, w->abt_type, w->cbp_table_index,
+                    s->inter_intra_pred);
          }
      }
-     s->esc3_level_length= 0;
-     s->esc3_run_length= 0;
- s->picture_number++; //FIXME ?
+     s->esc3_level_length = 0;
+     s->esc3_run_length   = 0;
+     s->picture_number++; // FIXME ?
  
-     if(w->j_type){
-         ff_intrax8_decode_picture(&w->x8, 2*s->qscale, (s->qscale-1)|1 );
+     if (w->j_type) {
+         ff_intrax8_decode_picture(&w->x8, 2 * s->qscale, (s->qscale - 1) | 1);
          return 1;
      }
  
      return 0;
  }
  
- static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr){
-     MpegEncContext * const s= &w->s;
+ static inline int wmv2_decode_motion(Wmv2Context *w, int *mx_ptr, int *my_ptr)
+ {
+     MpegEncContext *const s = &w->s;
      int ret;
  
-     ret= ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
+     ret = ff_msmpeg4_decode_motion(s, mx_ptr, my_ptr);
  
-     if(ret<0) return -1;
+     if (ret < 0)
+         return -1;
  
-     if((((*mx_ptr)|(*my_ptr)) & 1) && s->mspel)
-         w->hshift= get_bits1(&s->gb);
+     if ((((*mx_ptr) | (*my_ptr)) & 1) && s->mspel)
+         w->hshift = get_bits1(&s->gb);
      else
-         w->hshift= 0;
+         w->hshift = 0;
  
      return 0;
  }
  
- static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py){
-     MpegEncContext * const s= &w->s;
+ static int16_t *wmv2_pred_motion(Wmv2Context *w, int *px, int *py)
+ {
+     MpegEncContext *const s = &w->s;
      int xy, wrap, diff, type;
      int16_t *A, *B, *C, *mot_val;
  
-     wrap = s->b8_stride;
-     xy = s->block_index[0];
+     wrap    = s->b8_stride;
+     xy      = s->block_index[0];
  
      mot_val = s->current_picture.motion_val[0][xy];
  
-     A = s->current_picture.motion_val[0][xy - 1];
-     B = s->current_picture.motion_val[0][xy - wrap];
-     C = s->current_picture.motion_val[0][xy + 2 - wrap];
+     A       = s->current_picture.motion_val[0][xy     - 1];
+     B       = s->current_picture.motion_val[0][xy     - wrap];
+     C       = s->current_picture.motion_val[0][xy + 2 - wrap];
  
-     if(s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
-         diff= FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
+     if (s->mb_x && !s->first_slice_line && !s->mspel && w->top_left_mv_flag)
+         diff = FFMAX(FFABS(A[0] - B[0]), FFABS(A[1] - B[1]));
      else
-         diff=0;
+         diff = 0;
  
-     if(diff >= 8)
-         type= get_bits1(&s->gb);
+     if (diff >= 8)
+         type = get_bits1(&s->gb);
      else
-         type= 2;
-     if(type == 0){
-         *px= A[0];
-         *py= A[1];
-     }else if(type == 1){
-         *px= B[0];
-         *py= B[1];
-     }else{
+         type = 2;
+     if (type == 0) {
+         *px = A[0];
+         *py = A[1];
+     } else if (type == 1) {
+         *px = B[0];
+         *py = B[1];
+     } else {
          /* special case for first (slice) line */
          if (s->first_slice_line) {
              *px = A[0];
      return mot_val;
  }
  
- static inline int wmv2_decode_inter_block(Wmv2Context *w, int16_t *block, int n, int cbp){
-     MpegEncContext * const s= &w->s;
-     static const int sub_cbp_table[3]= {2,3,1};
+ static inline int wmv2_decode_inter_block(Wmv2Context *w, int16_t *block,
+                                           int n, int cbp)
+ {
+     MpegEncContext *const s = &w->s;
+     static const int sub_cbp_table[3] = { 2, 3, 1 };
      int sub_cbp;
  
-     if(!cbp){
+     if (!cbp) {
          s->block_last_index[n] = -1;
          return 0;
      }
  
-     if(w->per_block_abt)
-         w->abt_type= decode012(&s->gb);
-     w->abt_type_table[n]= w->abt_type;
+     if (w->per_block_abt)
+         w->abt_type = decode012(&s->gb);
+     w->abt_type_table[n] = w->abt_type;
  
-     if(w->abt_type){
- //        const uint8_t *scantable= w->abt_scantable[w->abt_type-1].permutated;
-         const uint8_t *scantable= w->abt_scantable[w->abt_type-1].scantable;
- //        const uint8_t *scantable= w->abt_type-1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable;
+     if (w->abt_type) {
+ //        const uint8_t *scantable = w->abt_scantable[w->abt_type - 1].permutated;
+         const uint8_t *scantable = w->abt_scantable[w->abt_type - 1].scantable;
+ //        const uint8_t *scantable = w->abt_type - 1 ? w->abt_scantable[1].permutated : w->abt_scantable[0].scantable;
  
-         sub_cbp= sub_cbp_table[ decode012(&s->gb) ];
+         sub_cbp = sub_cbp_table[decode012(&s->gb)];
  
-         if(sub_cbp&1){
+         if (sub_cbp & 1)
              if (ff_msmpeg4_decode_block(s, block, n, 1, scantable) < 0)
                  return -1;
-         }
  
-         if(sub_cbp&2){
+         if (sub_cbp & 2)
              if (ff_msmpeg4_decode_block(s, w->abt_block2[n], n, 1, scantable) < 0)
                  return -1;
-         }
          s->block_last_index[n] = 63;
  
          return 0;
-     }else{
-         return ff_msmpeg4_decode_block(s, block, n, 1, s->inter_scantable.permutated);
+     } else {
+         return ff_msmpeg4_decode_block(s, block, n, 1,
+                                        s->inter_scantable.permutated);
      }
  }
  
  int ff_wmv2_decode_mb(MpegEncContext *s, int16_t block[6][64])
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
      int cbp, code, i;
      uint8_t *coded_val;
  
-     if(w->j_type) return 0;
+     if (w->j_type)
+         return 0;
  
      if (s->pict_type == AV_PICTURE_TYPE_P) {
          if (IS_SKIP(s->current_picture.mb_type[s->mb_y * s->mb_stride + s->mb_x])) {
              /* skip mb */
              s->mb_intra = 0;
-             for(i=0;i<6;i++)
+             for (i = 0; i < 6; i++)
                  s->block_last_index[i] = -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->mv[0][0][0] = 0;
              s->mv[0][0][1] = 0;
-             s->mb_skipped = 1;
-             w->hshift=0;
+             s->mb_skipped  = 1;
+             w->hshift      = 0;
              return 0;
          }
  
-         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index].table, MB_NON_INTRA_VLC_BITS, 3);
+         code = get_vlc2(&s->gb, ff_mb_non_intra_vlc[w->cbp_table_index].table,
+                         MB_NON_INTRA_VLC_BITS, 3);
          if (code < 0)
              return -1;
          s->mb_intra = (~code & 0x40) >> 6;
      } else {
          s->mb_intra = 1;
          code = get_vlc2(&s->gb, ff_msmp4_mb_i_vlc.table, MB_INTRA_VLC_BITS, 2);
-         if (code < 0){
-             av_log(s->avctx, AV_LOG_ERROR, "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y);
+         if (code < 0) {
+             av_log(s->avctx, AV_LOG_ERROR,
+                    "II-cbp illegal at %d %d\n", s->mb_x, s->mb_y);
              return -1;
          }
          /* predict coded block pattern */
          cbp = 0;
-         for(i=0;i<6;i++) {
+         for (i = 0; i < 6; i++) {
              int val = ((code >> (5 - i)) & 1);
              if (i < 4) {
-                 int pred = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
-                 val = val ^ pred;
+                 int pred   = ff_msmpeg4_coded_block_pred(s, i, &coded_val);
+                 val        = val ^ pred;
                  *coded_val = val;
              }
              cbp |= val << (5 - i);
          int mx, my;
          wmv2_pred_motion(w, &mx, &my);
  
-         if(cbp){
+         if (cbp) {
              s->bdsp.clear_blocks(s->block[0]);
-             if(s->per_mb_rl_table){
-                 s->rl_table_index = decode012(&s->gb);
+             if (s->per_mb_rl_table) {
+                 s->rl_table_index        = decode012(&s->gb);
                  s->rl_chroma_table_index = s->rl_table_index;
              }
  
-             if(w->abt_flag && w->per_mb_abt){
-                 w->per_block_abt= get_bits1(&s->gb);
-                 if(!w->per_block_abt)
-                     w->abt_type= decode012(&s->gb);
-             }else
-                 w->per_block_abt=0;
+             if (w->abt_flag && w->per_mb_abt) {
+                 w->per_block_abt = get_bits1(&s->gb);
+                 if (!w->per_block_abt)
+                     w->abt_type = decode012(&s->gb);
+             } else
+                 w->per_block_abt = 0;
          }
  
          if (wmv2_decode_motion(w, &mx, &my) < 0)
              return -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->mv[0][0][0] = mx;
          s->mv[0][0][1] = my;
  
          for (i = 0; i < 6; i++) {
-             if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0)
-             {
-                 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding inter block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+             if (wmv2_decode_inter_block(w, block[i], i, (cbp >> (5 - i)) & 1) < 0) {
+                 av_log(s->avctx, AV_LOG_ERROR,
+                        "\nerror while decoding inter block: %d x %d (%d)\n",
+                        s->mb_x, s->mb_y, i);
                  return -1;
              }
          }
      } else {
-         if (s->pict_type==AV_PICTURE_TYPE_P)
+         if (s->pict_type == AV_PICTURE_TYPE_P)
              av_dlog(s->avctx, "%d%d ", s->inter_intra_pred, cbp);
          av_dlog(s->avctx, "I at %d %d %d %06X\n", s->mb_x, s->mb_y,
-                 ((cbp & 3) ? 1 : 0) +((cbp & 0x3C)? 2 : 0),
+                 ((cbp & 3) ? 1 : 0) + ((cbp & 0x3C) ? 2 : 0),
                  show_bits(&s->gb, 24));
          s->ac_pred = get_bits1(&s->gb);
-         if(s->inter_intra_pred){
-             s->h263_aic_dir= get_vlc2(&s->gb, ff_inter_intra_vlc.table, INTER_INTRA_VLC_BITS, 1);
+         if (s->inter_intra_pred) {
+             s->h263_aic_dir = get_vlc2(&s->gb, ff_inter_intra_vlc.table,
+                                        INTER_INTRA_VLC_BITS, 1);
              av_dlog(s->avctx, "%d%d %d %d/",
                      s->ac_pred, s->h263_aic_dir, s->mb_x, s->mb_y);
          }
-         if(s->per_mb_rl_table && cbp){
-             s->rl_table_index = decode012(&s->gb);
+         if (s->per_mb_rl_table && cbp) {
+             s->rl_table_index        = decode012(&s->gb);
              s->rl_chroma_table_index = s->rl_table_index;
          }
  
          s->bdsp.clear_blocks(s->block[0]);
          for (i = 0; i < 6; i++) {
-             if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0)
-             {
-                 av_log(s->avctx, AV_LOG_ERROR, "\nerror while decoding intra block: %d x %d (%d)\n", s->mb_x, s->mb_y, i);
+             if (ff_msmpeg4_decode_block(s, block[i], i, (cbp >> (5 - i)) & 1, NULL) < 0) {
+                 av_log(s->avctx, AV_LOG_ERROR,
+                        "\nerror while decoding intra block: %d x %d (%d)\n",
+                        s->mb_x, s->mb_y, i);
                  return -1;
              }
          }
      return 0;
  }
  
- static av_cold int wmv2_decode_init(AVCodecContext *avctx){
-     Wmv2Context * const w= avctx->priv_data;
+ static av_cold int wmv2_decode_init(AVCodecContext *avctx)
+ {
+     Wmv2Context *const w = avctx->priv_data;
  
-     if(ff_msmpeg4_decode_init(avctx) < 0)
 +    avctx->flags |= CODEC_FLAG_EMU_EDGE;
 +
+     if (ff_msmpeg4_decode_init(avctx) < 0)
          return -1;
  
      ff_wmv2_common_init(w);
  
-     ff_intrax8_common_init(&w->x8,&w->s);
+     ff_intrax8_common_init(&w->x8, &w->s);
  
      return 0;
  }
@@@ -477,8 -488,6 +490,6 @@@ AVCodec ff_wmv2_decoder = 
      .close          = wmv2_decode_end,
      .decode         = ff_h263_decode_frame,
      .capabilities   = CODEC_CAP_DRAW_HORIZ_BAND | CODEC_CAP_DR1,
-     .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 },
  };
diff --combined libavcodec/wmv2enc.c
@@@ -1,48 -1,49 +1,49 @@@
  /*
 - * Copyright (c) 2002 The Libav Project
 + * Copyright (c) 2002 The FFmpeg Project
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
  #include "avcodec.h"
+ #include "h263.h"
  #include "mpegvideo.h"
  #include "msmpeg4.h"
  #include "msmpeg4data.h"
- #include "h263.h"
  #include "wmv2.h"
  
  
- static int encode_ext_header(Wmv2Context *w){
-     MpegEncContext * const s= &w->s;
+ static int encode_ext_header(Wmv2Context *w)
+ {
+     MpegEncContext *const s = &w->s;
      PutBitContext pb;
      int code;
  
      init_put_bits(&pb, s->avctx->extradata, s->avctx->extradata_size);
  
-     put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); //yes 29.97 -> 29
-     put_bits(&pb, 11, FFMIN(s->bit_rate/1024, 2047));
+     put_bits(&pb, 5, s->avctx->time_base.den / s->avctx->time_base.num); // yes 29.97 -> 29
+     put_bits(&pb, 11, FFMIN(s->bit_rate / 1024, 2047));
  
-     put_bits(&pb, 1, w->mspel_bit=1);
+     put_bits(&pb, 1, w->mspel_bit        = 1);
      put_bits(&pb, 1, s->loop_filter);
-     put_bits(&pb, 1, w->abt_flag=1);
-     put_bits(&pb, 1, w->j_type_bit=1);
-     put_bits(&pb, 1, w->top_left_mv_flag=0);
-     put_bits(&pb, 1, w->per_mb_rl_bit=1);
-     put_bits(&pb, 3, code=1);
+     put_bits(&pb, 1, w->abt_flag         = 1);
+     put_bits(&pb, 1, w->j_type_bit       = 1);
+     put_bits(&pb, 1, w->top_left_mv_flag = 0);
+     put_bits(&pb, 1, w->per_mb_rl_bit    = 1);
+     put_bits(&pb, 3, code                = 1);
  
      flush_put_bits(&pb);
  
      return 0;
  }
  
- static av_cold int wmv2_encode_init(AVCodecContext *avctx){
-     Wmv2Context * const w= avctx->priv_data;
+ static av_cold int wmv2_encode_init(AVCodecContext *avctx)
+ {
+     Wmv2Context *const w = avctx->priv_data;
  
      if (ff_mpv_encode_init(avctx) < 0)
          return -1;
  
      ff_wmv2_common_init(w);
  
-     avctx->extradata_size= 4;
-     avctx->extradata= av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
+     avctx->extradata_size = 4;
 -    avctx->extradata      = av_mallocz(avctx->extradata_size + 10);
++    avctx->extradata      = av_mallocz(avctx->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 +    if (!avctx->extradata)
 +        return AVERROR(ENOMEM);
      encode_ext_header(w);
  
      return 0;
  }
  
- int ff_wmv2_encode_picture_header(MpegEncContext * s, int picture_number)
+ int ff_wmv2_encode_picture_header(MpegEncContext *s, int picture_number)
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
  
      put_bits(&s->pb, 1, s->pict_type - 1);
-     if(s->pict_type == AV_PICTURE_TYPE_I){
+     if (s->pict_type == AV_PICTURE_TYPE_I)
          put_bits(&s->pb, 7, 0);
-     }
      put_bits(&s->pb, 5, s->qscale);
  
-     s->dc_table_index = 1;
-     s->mv_table_index = 1; /* only if P frame */
+     s->dc_table_index  = 1;
+     s->mv_table_index  = 1; /* only if P frame */
      s->per_mb_rl_table = 0;
-     s->mspel= 0;
-     w->per_mb_abt=0;
-     w->abt_type=0;
-     w->j_type=0;
+     s->mspel           = 0;
+     w->per_mb_abt      = 0;
+     w->abt_type        = 0;
+     w->j_type          = 0;
  
 -    assert(s->flipflop_rounding);
 +    av_assert0(s->flipflop_rounding);
  
      if (s->pict_type == AV_PICTURE_TYPE_I) {
-         av_assert0(s->no_rounding==1);
-         if(w->j_type_bit) put_bits(&s->pb, 1, w->j_type);
 -        assert(s->no_rounding == 1);
++        av_assert0(s->no_rounding == 1);
+         if (w->j_type_bit)
+             put_bits(&s->pb, 1, w->j_type);
  
-         if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
+         if (w->per_mb_rl_bit)
+             put_bits(&s->pb, 1, s->per_mb_rl_table);
  
-         if(!s->per_mb_rl_table){
+         if (!s->per_mb_rl_table) {
              ff_msmpeg4_code012(&s->pb, s->rl_chroma_table_index);
              ff_msmpeg4_code012(&s->pb, s->rl_table_index);
          }
  
          put_bits(&s->pb, 1, s->dc_table_index);
  
-         s->inter_intra_pred= 0;
-     }else{
+         s->inter_intra_pred = 0;
+     } else {
          int cbp_index;
  
          put_bits(&s->pb, 2, SKIP_TYPE_NONE);
  
-         ff_msmpeg4_code012(&s->pb, cbp_index=0);
-         if(s->qscale <= 10){
-             int map[3]= {0,2,1};
-             w->cbp_table_index= map[cbp_index];
-         }else if(s->qscale <= 20){
-             int map[3]= {1,0,2};
-             w->cbp_table_index= map[cbp_index];
-         }else{
-             int map[3]= {2,1,0};
-             w->cbp_table_index= map[cbp_index];
+         ff_msmpeg4_code012(&s->pb, cbp_index = 0);
+         if (s->qscale <= 10) {
+             int map[3]         = { 0, 2, 1 };
+             w->cbp_table_index = map[cbp_index];
+         } else if (s->qscale <= 20) {
+             int map[3]         = { 1, 0, 2 };
+             w->cbp_table_index = map[cbp_index];
+         } else {
+             int map[3]         = { 2, 1, 0 };
+             w->cbp_table_index = map[cbp_index];
          }
  
-         if(w->mspel_bit) put_bits(&s->pb, 1, s->mspel);
+         if (w->mspel_bit)
+             put_bits(&s->pb, 1, s->mspel);
  
-         if(w->abt_flag){
-             put_bits(&s->pb, 1, w->per_mb_abt^1);
-             if(!w->per_mb_abt){
+         if (w->abt_flag) {
+             put_bits(&s->pb, 1, w->per_mb_abt ^ 1);
+             if (!w->per_mb_abt)
                  ff_msmpeg4_code012(&s->pb, w->abt_type);
-             }
          }
  
-         if(w->per_mb_rl_bit) put_bits(&s->pb, 1, s->per_mb_rl_table);
+         if (w->per_mb_rl_bit)
+             put_bits(&s->pb, 1, s->per_mb_rl_table);
  
-         if(!s->per_mb_rl_table){
+         if (!s->per_mb_rl_table) {
              ff_msmpeg4_code012(&s->pb, s->rl_table_index);
              s->rl_chroma_table_index = s->rl_table_index;
          }
          put_bits(&s->pb, 1, s->dc_table_index);
          put_bits(&s->pb, 1, s->mv_table_index);
  
-         s->inter_intra_pred= 0;//(s->width*s->height < 320*240 && s->bit_rate<=II_BITRATE);
+         s->inter_intra_pred = 0; // (s->width * s->height < 320 * 240 && s->bit_rate <= II_BITRATE);
      }
-     s->esc3_level_length= 0;
-     s->esc3_run_length= 0;
+     s->esc3_level_length = 0;
+     s->esc3_run_length   = 0;
  
      return 0;
  }
  /* Nearly identical to wmv1 but that is just because we do not use the
   * useless M$ crap features. It is duplicated here in case someone wants
   * to add support for these crap features. */
- void ff_wmv2_encode_mb(MpegEncContext * s,
-                        int16_t block[6][64],
+ void ff_wmv2_encode_mb(MpegEncContext *s, int16_t block[6][64],
                         int motion_x, int motion_y)
  {
-     Wmv2Context * const w= (Wmv2Context*)s;
+     Wmv2Context *const w = (Wmv2Context *) s;
      int cbp, coded_cbp, i;
      int pred_x, pred_y;
      uint8_t *coded_block;
      if (!s->mb_intra) {
          /* compute cbp */
          cbp = 0;
-         for (i = 0; i < 6; i++) {
+         for (i = 0; i < 6; i++)
              if (s->block_last_index[i] >= 0)
                  cbp |= 1 << (5 - i);
-         }
  
          put_bits(&s->pb,
                   ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][1],
                   ff_wmv2_inter_table[w->cbp_table_index][cbp + 64][0]);
  
 +        s->misc_bits += get_bits_diff(s);
          /* motion vector */
          ff_h263_pred_motion(s, 0, 0, &pred_x, &pred_y);
          ff_msmpeg4_encode_motion(s, motion_x - pred_x,
-                               motion_y - pred_y);
+                                  motion_y - pred_y);
 +        s->mv_bits += get_bits_diff(s);
      } else {
          /* compute cbp */
-         cbp = 0;
+         cbp       = 0;
          coded_cbp = 0;
          for (i = 0; i < 6; i++) {
              int val, pred;
-             val = (s->block_last_index[i] >= 1);
+             val  = (s->block_last_index[i] >= 1);
              cbp |= val << (5 - i);
              if (i < 4) {
                  /* predict value for close blocks only for luma */
-                 pred = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
+                 pred         = ff_msmpeg4_coded_block_pred(s, i, &coded_block);
                  *coded_block = val;
-                 val = val ^ pred;
+                 val          = val ^ pred;
              }
              coded_cbp |= val << (5 - i);
          }
  
-         if (s->pict_type == AV_PICTURE_TYPE_I) {
+         if (s->pict_type == AV_PICTURE_TYPE_I)
              put_bits(&s->pb,
-                      ff_msmp4_mb_i_table[coded_cbp][1], ff_msmp4_mb_i_table[coded_cbp][0]);
-         } else {
+                      ff_msmp4_mb_i_table[coded_cbp][1],
+                      ff_msmp4_mb_i_table[coded_cbp][0]);
+         else
              put_bits(&s->pb,
                       ff_wmv2_inter_table[w->cbp_table_index][cbp][1],
                       ff_wmv2_inter_table[w->cbp_table_index][cbp][0]);
-         }
          put_bits(&s->pb, 1, 0);         /* no AC prediction yet */
-         if(s->inter_intra_pred){
-             s->h263_aic_dir=0;
-             put_bits(&s->pb, ff_table_inter_intra[s->h263_aic_dir][1], ff_table_inter_intra[s->h263_aic_dir][0]);
+         if (s->inter_intra_pred) {
+             s->h263_aic_dir = 0;
+             put_bits(&s->pb,
+                      ff_table_inter_intra[s->h263_aic_dir][1],
+                      ff_table_inter_intra[s->h263_aic_dir][0]);
          }
 +        s->misc_bits += get_bits_diff(s);
      }
  
-     for (i = 0; i < 6; i++) {
+     for (i = 0; i < 6; i++)
          ff_msmpeg4_encode_block(s, block[i], i);
-     }
 +    if (s->mb_intra)
 +        s->i_tex_bits += get_bits_diff(s);
 +    else
 +        s->p_tex_bits += get_bits_diff(s);
  }
  
  AVCodec ff_wmv2_encoder = {
      .init           = wmv2_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 },
  };