# HG changeset patch
# User diego
# Date 1234628066 0
# Node ID 8c11ebbca9b35914621ea4ba154084a79071ebdb
# Parent  1f4d7469a66337fe6fe06893a9dd98d8e4564830
whitespace cosmetics: consistent (more or less) K&R style

diff -r 1f4d7469a663 -r 8c11ebbca9b3 mpegvideo_xvmc.c
--- a/mpegvideo_xvmc.c	Sat Feb 14 16:05:36 2009 +0000
+++ b/mpegvideo_xvmc.c	Sat Feb 14 16:14:26 2009 +0000
@@ -36,25 +36,27 @@
 #include "xvmc.h"
 
 //set s->block
-void XVMC_init_block(MpegEncContext *s){
+void XVMC_init_block(MpegEncContext *s)
+{
     struct xvmc_render_state * render;
     render = (struct xvmc_render_state*)s->current_picture.data[2];
     assert(render != NULL);
-    if( (render == NULL) || (render->magic != MP_XVMC_RENDER_MAGIC) ){
+    if ((render == NULL) || (render->magic != MP_XVMC_RENDER_MAGIC)) {
         assert(0);
         return;//make sure that this is a render packet
     }
     s->block =(DCTELEM *)(render->data_blocks+(render->next_free_data_block_num)*64);
 }
 
-void XVMC_pack_pblocks(MpegEncContext *s, int cbp){
+void XVMC_pack_pblocks(MpegEncContext *s, int cbp)
+{
     int i,j;
-    const int mb_block_count = 4+(1<<s->chroma_format);
+    const int mb_block_count = 4 + (1 << s->chroma_format);
 
-    j=0;
-    cbp<<= 12-mb_block_count;
-    for(i=0; i<mb_block_count; i++){
-        if(cbp & (1<<11)) {
+    j = 0;
+    cbp <<= 12-mb_block_count;
+    for (i = 0; i < mb_block_count; i++) {
+        if (cbp & (1<<11)) {
             s->pblocks[i] = (short *)(&s->block[(j++)]);
         }else{
             s->pblocks[i] = NULL;
@@ -65,14 +67,15 @@
 
 //These functions should be called on every new field and/or frame.
 //They should be safe if they are called a few times for the same field!
-int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx){
+int XVMC_field_start(MpegEncContext*s, AVCodecContext *avctx)
+{
     struct xvmc_render_state * render, * last, * next;
 
     assert(avctx != NULL);
 
     render = (struct xvmc_render_state*)s->current_picture.data[2];
     assert(render != NULL);
-    if( (render == NULL) || (render->magic != MP_XVMC_RENDER_MAGIC) )
+    if ((render == NULL) || (render->magic != MP_XVMC_RENDER_MAGIC))
         return -1;//make sure that this is render packet
 
     render->picture_structure = s->picture_structure;
@@ -91,15 +94,18 @@
             next = (struct xvmc_render_state*)s->next_picture.data[2];
             assert(next!=NULL);
             assert(next->state & MP_XVMC_STATE_PREDICTION);
-            if(next == NULL) return -1;
-            if(next->magic != MP_XVMC_RENDER_MAGIC) return -1;
+            if (next == NULL)
+                return -1;
+            if (next->magic != MP_XVMC_RENDER_MAGIC)
+                return -1;
             render->p_future_surface = next->p_surface;
             //no return here, going to set forward prediction
         case  FF_P_TYPE:
             last = (struct xvmc_render_state*)s->last_picture.data[2];
-            if(last == NULL)// && !s->first_field)
+            if (last == NULL)// && !s->first_field)
                 last = render;//predict second field from the first
-            if(last->magic != MP_XVMC_RENDER_MAGIC) return -1;
+            if (last->magic != MP_XVMC_RENDER_MAGIC)
+                return -1;
             assert(last->state & MP_XVMC_STATE_PREDICTION);
             render->p_past_surface = last->p_surface;
             return 0;
@@ -108,17 +114,18 @@
 return -1;
 }
 
-void XVMC_field_end(MpegEncContext *s){
+void XVMC_field_end(MpegEncContext *s)
+{
     struct xvmc_render_state * render;
     render = (struct xvmc_render_state*)s->current_picture.data[2];
     assert(render != NULL);
 
-    if(render->filled_mv_blocks_num > 0){
+    if (render->filled_mv_blocks_num > 0)
         ff_draw_horiz_band(s,0,0);
-    }
 }
 
-void XVMC_decode_mb(MpegEncContext *s){
+void XVMC_decode_mb(MpegEncContext *s)
+{
     XvMCMacroBlock * mv_block;
     struct xvmc_render_state * render;
     int i,cbp,blocks_per_mb;
@@ -126,7 +133,7 @@
     const int mb_xy = s->mb_y * s->mb_stride + s->mb_x;
 
 
-    if(s->encoding){
+    if (s->encoding) {
         av_log(s->avctx, AV_LOG_ERROR, "XVMC doesn't support encoding!!!\n");
         return;
     }
@@ -160,12 +167,12 @@
     mv_block->x = s->mb_x;
     mv_block->y = s->mb_y;
     mv_block->dct_type = s->interlaced_dct;//XVMC_DCT_TYPE_FRAME/FIELD;
-    if(s->mb_intra){
+    if (s->mb_intra){
         mv_block->macroblock_type = XVMC_MB_TYPE_INTRA;//no MC, all done
     }else{
         mv_block->macroblock_type = XVMC_MB_TYPE_PATTERN;
 
-        if(s->mv_dir & MV_DIR_FORWARD){
+        if (s->mv_dir & MV_DIR_FORWARD) {
             mv_block->macroblock_type|= XVMC_MB_TYPE_MOTION_FORWARD;
             //pmv[n][dir][xy]=mv[dir][n][xy]
             mv_block->PMV[0][0][0] = s->mv[0][0][0];
@@ -173,7 +180,7 @@
             mv_block->PMV[1][0][0] = s->mv[0][1][0];
             mv_block->PMV[1][0][1] = s->mv[0][1][1];
         }
-        if(s->mv_dir & MV_DIR_BACKWARD){
+        if (s->mv_dir & MV_DIR_BACKWARD) {
             mv_block->macroblock_type|=XVMC_MB_TYPE_MOTION_BACKWARD;
             mv_block->PMV[0][1][0] = s->mv[1][0][0];
             mv_block->PMV[0][1][1] = s->mv[1][0][1];
@@ -190,16 +197,16 @@
                 break;
             case  MV_TYPE_FIELD:
                 mv_block->motion_type = XVMC_PREDICTION_FIELD;
-                if(s->picture_structure == PICT_FRAME){
-                    mv_block->PMV[0][0][1]<<=1;
-                    mv_block->PMV[1][0][1]<<=1;
-                    mv_block->PMV[0][1][1]<<=1;
-                    mv_block->PMV[1][1][1]<<=1;
+                if (s->picture_structure == PICT_FRAME) {
+                    mv_block->PMV[0][0][1] <<= 1;
+                    mv_block->PMV[1][0][1] <<= 1;
+                    mv_block->PMV[0][1][1] <<= 1;
+                    mv_block->PMV[1][1][1] <<= 1;
                 }
                 break;
             case  MV_TYPE_DMV:
                 mv_block->motion_type = XVMC_PREDICTION_DUAL_PRIME;
-                if(s->picture_structure == PICT_FRAME){
+                if (s->picture_structure == PICT_FRAME) {
 
                     mv_block->PMV[0][0][0] = s->mv[0][0][0];//top from top
                     mv_block->PMV[0][0][1] = s->mv[0][0][1]<<1;
@@ -225,56 +232,60 @@
         mv_block->motion_vertical_field_select = 0;
 
 //set correct field references
-        if(s->mv_type == MV_TYPE_FIELD || s->mv_type == MV_TYPE_16X8){
-            if( s->field_select[0][0] ) mv_block->motion_vertical_field_select|=1;
-            if( s->field_select[1][0] ) mv_block->motion_vertical_field_select|=2;
-            if( s->field_select[0][1] ) mv_block->motion_vertical_field_select|=4;
-            if( s->field_select[1][1] ) mv_block->motion_vertical_field_select|=8;
+        if (s->mv_type == MV_TYPE_FIELD || s->mv_type == MV_TYPE_16X8) {
+            if (s->field_select[0][0])
+                mv_block->motion_vertical_field_select |= 1;
+            if (s->field_select[1][0])
+                mv_block->motion_vertical_field_select |= 2;
+            if (s->field_select[0][1])
+                mv_block->motion_vertical_field_select |= 4;
+            if (s->field_select[1][1])
+                mv_block->motion_vertical_field_select |= 8;
         }
     }//!intra
 //time to handle data blocks;
     mv_block->index = render->next_free_data_block_num;
 
     blocks_per_mb = 6;
-    if( s->chroma_format >= 2){
+    if (s->chroma_format >= 2) {
         blocks_per_mb = 4 + (1 << (s->chroma_format));
     }
 
 //  calculate cbp
     cbp = 0;
-    for(i=0; i<blocks_per_mb; i++) {
+    for (i = 0; i < blocks_per_mb; i++) {
         cbp+= cbp;
-        if(s->block_last_index[i] >= 0)
+        if (s->block_last_index[i] >= 0)
             cbp++;
     }
 
-    if(s->flags & CODEC_FLAG_GRAY){
-        if(s->mb_intra){//intra frames are always full chroma block
-            for(i=4; i<blocks_per_mb; i++){
+    if (s->flags & CODEC_FLAG_GRAY) {
+        if (s->mb_intra){//intra frames are always full chroma block
+            for (i = 4; i < blocks_per_mb; i++) {
                 memset(s->pblocks[i],0,sizeof(short)*8*8);//so we need to clear them
-                if(!render->unsigned_intra)
-                    s->pblocks[i][0] = 1<<10;
+                if (!render->unsigned_intra)
+                    s->pblocks[i][0] = 1 << 10;
             }
         }else{
-            cbp&= 0xf << (blocks_per_mb - 4);
+            cbp &= 0xf << (blocks_per_mb - 4);
             blocks_per_mb = 4;//luminance blocks only
         }
     }
     mv_block->coded_block_pattern = cbp;
-    if(cbp == 0)
+    if (cbp == 0)
         mv_block->macroblock_type &= ~XVMC_MB_TYPE_PATTERN;
 
-    for(i=0; i<blocks_per_mb; i++){
-        if(s->block_last_index[i] >= 0){
+    for (i = 0; i < blocks_per_mb; i++) {
+        if (s->block_last_index[i] >= 0) {
             // I do not have unsigned_intra MOCO to test, hope it is OK.
-            if( (s->mb_intra) && ( render->idct || (!render->idct && !render->unsigned_intra)) )
-                s->pblocks[i][0]-=1<<10;
-            if(!render->idct){
+            if ((s->mb_intra) && (render->idct || (!render->idct && !render->unsigned_intra)))
+                s->pblocks[i][0] -= 1 << 10;
+            if (!render->idct) {
                 s->dsp.idct(s->pblocks[i]);
                 //!!TODO!clip!!!
             }
 //copy blocks only if the codec doesn't support pblocks reordering
-            if(s->avctx->xvmc_acceleration == 1){
+            if (s->avctx->xvmc_acceleration == 1) {
                 memcpy(&render->data_blocks[(render->next_free_data_block_num)*64],
                        s->pblocks[i],sizeof(short)*8*8);
             }
@@ -287,6 +298,6 @@
     assert(render->next_free_data_block_num <= render->total_number_of_data_blocks);
 
 
-    if(render->filled_mv_blocks_num >= render->total_number_of_mv_blocks)
+    if (render->filled_mv_blocks_num >= render->total_number_of_mv_blocks)
         ff_draw_horiz_band(s,0,0);
 }