COSMETICS: tabs --> spaces, some prettyprinting

Originally committed as revision 4764 to svn://svn.ffmpeg.org/ffmpeg/trunk

1 files changed, 184 insertions, 184 deletions

diff --git a/libavcodec/dv.c b/libavcodec/dv.c
index 7adaac648e..dae7fdd9eb 100644
--- a/libavcodec/dv.c
+++ b/libavcodec/dv.c
@@ -84,7 +84,7 @@ static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
             j = perm[i];
             s->dv_idct_shift[0][0][q][j] =
                 dv_quant_shifts[q][dv_88_areas[i]] + 1;
-	    s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
+            s->dv_idct_shift[1][0][q][j] = s->dv_idct_shift[0][0][q][j] + 1;
         }
 
         /* 248DCT */
@@ -92,7 +92,7 @@ static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
             /* 248 table */
             s->dv_idct_shift[0][1][q][i] =
                 dv_quant_shifts[q][dv_248_areas[i]] + 1;
-	    s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
+            s->dv_idct_shift[1][1][q][i] = s->dv_idct_shift[0][1][q][i] + 1;
         }
     }
 }
@@ -114,35 +114,35 @@ static int dvvideo_init(AVCodecContext *avctx)
         done = 1;
 
         dv_vlc_map = av_mallocz_static(DV_VLC_MAP_LEV_SIZE*DV_VLC_MAP_RUN_SIZE*sizeof(struct dv_vlc_pair));
-	if (!dv_vlc_map)
-	    return -ENOMEM;
-
-	/* dv_anchor lets each thread know its Id */
-	dv_anchor = av_malloc(12*27*sizeof(void*));
-	if (!dv_anchor) {
-	    return -ENOMEM;
-	}
-	for (i=0; i<12*27; i++)
-	    dv_anchor[i] = (void*)(size_t)i;
-
-	/* it's faster to include sign bit in a generic VLC parsing scheme */
-	for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
-	    new_dv_vlc_bits[j] = dv_vlc_bits[i];
-	    new_dv_vlc_len[j] = dv_vlc_len[i];
-	    new_dv_vlc_run[j] = dv_vlc_run[i];
-	    new_dv_vlc_level[j] = dv_vlc_level[i];
-
-	    if (dv_vlc_level[i]) {
-	        new_dv_vlc_bits[j] <<= 1;
-		new_dv_vlc_len[j]++;
-
-		j++;
-		new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
-		new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
-		new_dv_vlc_run[j] = dv_vlc_run[i];
-		new_dv_vlc_level[j] = -dv_vlc_level[i];
-	    }
-	}
+        if (!dv_vlc_map)
+            return -ENOMEM;
+
+        /* dv_anchor lets each thread know its Id */
+        dv_anchor = av_malloc(12*27*sizeof(void*));
+        if (!dv_anchor) {
+            return -ENOMEM;
+        }
+        for (i=0; i<12*27; i++)
+            dv_anchor[i] = (void*)(size_t)i;
+
+        /* it's faster to include sign bit in a generic VLC parsing scheme */
+        for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
+            new_dv_vlc_bits[j] = dv_vlc_bits[i];
+            new_dv_vlc_len[j] = dv_vlc_len[i];
+            new_dv_vlc_run[j] = dv_vlc_run[i];
+            new_dv_vlc_level[j] = dv_vlc_level[i];
+
+            if (dv_vlc_level[i]) {
+                new_dv_vlc_bits[j] <<= 1;
+                new_dv_vlc_len[j]++;
+
+                j++;
+                new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
+                new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
+                new_dv_vlc_run[j] = dv_vlc_run[i];
+                new_dv_vlc_level[j] = -dv_vlc_level[i];
+            }
+        }
 
         /* NOTE: as a trick, we use the fact the no codes are unused
            to accelerate the parsing of partial codes */
@@ -150,10 +150,10 @@ static int dvvideo_init(AVCodecContext *avctx)
                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 
         dv_rl_vlc = av_malloc(dv_vlc.table_size * sizeof(RL_VLC_ELEM));
-	if (!dv_rl_vlc) {
-	    av_free(dv_anchor);
-	    return -ENOMEM;
-	}
+        if (!dv_rl_vlc) {
+            av_free(dv_anchor);
+            return -ENOMEM;
+        }
         for(i = 0; i < dv_vlc.table_size; i++){
             int code= dv_vlc.table[i][0];
             int len = dv_vlc.table[i][1];
@@ -170,49 +170,49 @@ static int dvvideo_init(AVCodecContext *avctx)
             dv_rl_vlc[i].level = level;
             dv_rl_vlc[i].run = run;
         }
-	free_vlc(&dv_vlc);
+        free_vlc(&dv_vlc);
 
-	for (i = 0; i < NB_DV_VLC - 1; i++) {
+        for (i = 0; i < NB_DV_VLC - 1; i++) {
            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
-	       continue;
+               continue;
 #ifdef DV_CODEC_TINY_TARGET
            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
-	       continue;
+               continue;
 #endif
 
-	   if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
-	       continue;
+           if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
+               continue;
 
-	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
-	                                                    (!!dv_vlc_level[i]);
-	   dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
-	                                                     (!!dv_vlc_level[i]);
-	}
-	for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
+           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
+                                                            (!!dv_vlc_level[i]);
+           dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
+                                                             (!!dv_vlc_level[i]);
+        }
+        for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
 #ifdef DV_CODEC_TINY_TARGET
-	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
-	      if (dv_vlc_map[i][j].size == 0) {
-	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
-		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
-	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
-		                          dv_vlc_map[0][j].size;
-	      }
-	   }
+           for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
+              if (dv_vlc_map[i][j].size == 0) {
+                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
+                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
+                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
+                                          dv_vlc_map[0][j].size;
+              }
+           }
 #else
-	   for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
-	      if (dv_vlc_map[i][j].size == 0) {
-	          dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
-		            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
-	          dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
-		                          dv_vlc_map[0][j].size;
-	      }
-	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
-	                                    dv_vlc_map[i][j].vlc | 1;
-	      dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
-	                                    dv_vlc_map[i][j].size;
-	   }
+           for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
+              if (dv_vlc_map[i][j].size == 0) {
+                  dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
+                            (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
+                  dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
+                                          dv_vlc_map[0][j].size;
+              }
+              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
+                                            dv_vlc_map[i][j].vlc | 1;
+              dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
+                                            dv_vlc_map[i][j].size;
+           }
 #endif
-	}
+        }
     }
 
     /* Generic DSP setup */
@@ -241,7 +241,7 @@ static int dvvideo_init(AVCodecContext *avctx)
 
     /* FIXME: I really don't think this should be here */
     if (dv_codec_profile(avctx))
-	avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
+        avctx->pix_fmt = dv_codec_profile(avctx)->pix_fmt;
     avctx->coded_frame = &s->picture;
     s->avctx= avctx;
 
@@ -306,9 +306,9 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
     /* if we must parse a partial vlc, we do it here */
     if (partial_bit_count > 0) {
         re_cache = ((unsigned)re_cache >> partial_bit_count) |
-	           (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
-	re_index -= partial_bit_count;
-	mb->partial_bit_count = 0;
+                   (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
+        re_index -= partial_bit_count;
+        mb->partial_bit_count = 0;
     }
 
     /* get the AC coefficients until last_index is reached */
@@ -318,30 +318,30 @@ static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 #endif
         /* our own optimized GET_RL_VLC */
         index = NEG_USR32(re_cache, TEX_VLC_BITS);
-	vlc_len = dv_rl_vlc[index].len;
+        vlc_len = dv_rl_vlc[index].len;
         if (vlc_len < 0) {
             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
             vlc_len = TEX_VLC_BITS - vlc_len;
         }
         level = dv_rl_vlc[index].level;
-	run = dv_rl_vlc[index].run;
-
-	/* gotta check if we're still within gb boundaries */
-	if (re_index + vlc_len > last_index) {
-	    /* should be < 16 bits otherwise a codeword could have been parsed */
-	    mb->partial_bit_count = last_index - re_index;
-	    mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
-	    re_index = last_index;
-	    break;
-	}
-	re_index += vlc_len;
+        run = dv_rl_vlc[index].run;
+
+        /* gotta check if we're still within gb boundaries */
+        if (re_index + vlc_len > last_index) {
+            /* should be < 16 bits otherwise a codeword could have been parsed */
+            mb->partial_bit_count = last_index - re_index;
+            mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
+            re_index = last_index;
+            break;
+        }
+        re_index += vlc_len;
 
 #ifdef VLC_DEBUG
-	printf("run=%d level=%d\n", run, level);
+        printf("run=%d level=%d\n", run, level);
 #endif
-	pos += run;
-	if (pos >= 64)
-	    break;
+        pos += run;
+        if (pos >= 64)
+            break;
 
         assert(level);
         pos1 = scan_table[pos];
@@ -404,7 +404,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
         block = block1;
         for(j = 0;j < 6; j++) {
             last_index = block_sizes[j];
-	    init_get_bits(&gb, buf_ptr, last_index);
+            init_get_bits(&gb, buf_ptr, last_index);
 
             /* get the dc */
             dc = get_sbits(&gb, 9);
@@ -444,7 +444,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
         block = block1;
         mb = mb1;
         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
-	flush_put_bits(&pb);
+        flush_put_bits(&pb);
         for(j = 0;j < 6; j++, block += 64, mb++) {
             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
                 dv_decode_ac(&gb, mb, block);
@@ -456,7 +456,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
         /* all blocks are finished, so the extra bytes can be used at
            the video segment level */
         if (j >= 6)
-	    bit_copy(&vs_pb, &gb);
+            bit_copy(&vs_pb, &gb);
     }
 
     /* we need a pass other the whole video segment */
@@ -475,8 +475,8 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
 #endif
                 dv_decode_ac(&gb, mb, block);
             }
-	    if (mb->pos >= 64 && mb->pos < 127)
-		av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
+            if (mb->pos >= 64 && mb->pos < 127)
+                av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
             block += 64;
             mb++;
         }
@@ -508,7 +508,7 @@ static inline void dv_decode_video_segment(DVVideoContext *s,
                 if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
                     uint64_t aligned_pixels[64/8];
                     uint8_t *pixels= (uint8_t*)aligned_pixels;
-		    uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
+                    uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
                     int x, y, linesize;
                     /* NOTE: at end of line, the macroblock is handled as 420 */
                     idct_put(pixels, 8, block);
@@ -543,21 +543,21 @@ static always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
     int size;
     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
         *vlc = dv_vlc_map[run][level].vlc | sign;
-	size = dv_vlc_map[run][level].size;
+        size = dv_vlc_map[run][level].size;
     }
     else {
         if (level < DV_VLC_MAP_LEV_SIZE) {
-	    *vlc = dv_vlc_map[0][level].vlc | sign;
-	    size = dv_vlc_map[0][level].size;
-	} else {
+            *vlc = dv_vlc_map[0][level].vlc | sign;
+            size = dv_vlc_map[0][level].size;
+        } else {
             *vlc = 0xfe00 | (level << 1) | sign;
-	    size = 16;
-	}
-	if (run) {
-	    *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
-	                          (0x1f80 | (run - 1))) << size;
-	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
-	}
+            size = 16;
+        }
+        if (run) {
+            *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
+                                  (0x1f80 | (run - 1))) << size;
+            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
+        }
     }
 
     return size;
@@ -568,13 +568,13 @@ static always_inline int dv_rl2vlc_size(int run, int level)
     int size;
 
     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
-	size = dv_vlc_map[run][level].size;
+        size = dv_vlc_map[run][level].size;
     }
     else {
-	size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
-	if (run) {
-	    size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
-	}
+        size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
+        if (run) {
+            size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
+        }
     }
     return size;
 }
@@ -620,14 +620,14 @@ static always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext
        for (; size > (bits_left = put_bits_left(pb)); pb++) {
           if (bits_left) {
               size -= bits_left;
-	      put_bits(pb, bits_left, vlc >> size);
-	      vlc = vlc & ((1<<size)-1);
-	  }
-	  if (pb + 1 >= pb_end) {
-	      bi->partial_bit_count = size;
-	      bi->partial_bit_buffer = vlc;
-	      return pb;
-	  }
+              put_bits(pb, bits_left, vlc >> size);
+              vlc = vlc & ((1<<size)-1);
+          }
+          if (pb + 1 >= pb_end) {
+              bi->partial_bit_count = size;
+              bi->partial_bit_buffer = vlc;
+              return pb;
+          }
        }
 
        /* Store VLC */
@@ -712,14 +712,14 @@ static always_inline int dv_guess_dct_mode(DCTELEM *blk) {
     s = blk;
     for(i=0; i<7; i++) {
         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
-	           SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
+                   SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
         s += 8;
     }
     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
     s = blk;
     for(i=0; i<6; i++) {
         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
-	            SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
+                    SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
         s += 8;
     }
 
@@ -736,30 +736,30 @@ static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
        b = blks;
        for (i=0; i<5; i++) {
           if (!qnos[i])
-	      continue;
+              continue;
 
-	  qnos[i]--;
-	  size[i] = 0;
+          qnos[i]--;
+          size[i] = 0;
           for (j=0; j<6; j++, b++) {
-	     for (a=0; a<4; a++) {
-	        if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
-		    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
-		    b->area_q[a]++;
+             for (a=0; a<4; a++) {
+                if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
+                    b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
+                    b->area_q[a]++;
                     prev= b->prev[a];
                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
-		       b->mb[k] >>= 1;
-		       if (b->mb[k]) {
+                       b->mb[k] >>= 1;
+                       if (b->mb[k]) {
                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
-	                   prev= k;
+                           prev= k;
                        } else {
                            b->next[prev] = b->next[k];
                        }
-		    }
+                    }
                     b->prev[a+1]= prev;
-		}
-		size[i] += b->bit_size[a];
-	     }
-	  }
+                }
+                size[i] += b->bit_size[a];
+             }
+          }
        }
     } while ((vs_total_ac_bits < size[0] + size[1] + size[2] + size[3] + size[4]) &&
              (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]));
@@ -797,68 +797,68 @@ static inline void dv_encode_video_segment(DVVideoContext *s,
         mb_x = v & 0xff;
         mb_y = v >> 8;
         y_ptr = s->picture.data[0] + (mb_y * s->picture.linesize[0] * 8) + (mb_x * 8);
-	c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
-	           ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
-		   (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
-	do_edge_wrap = 0;
-	qnos[mb_index] = 15; /* No quantization */
+        c_offset = (s->sys->pix_fmt == PIX_FMT_YUV411P) ?
+                   ((mb_y * s->picture.linesize[1] * 8) + ((mb_x >> 2) * 8)) :
+                   (((mb_y >> 1) * s->picture.linesize[1] * 8) + ((mb_x >> 1) * 8));
+        do_edge_wrap = 0;
+        qnos[mb_index] = 15; /* No quantization */
         ptr = dif + mb_index*80 + 4;
         for(j = 0;j < 6; j++) {
             if (j < 4) {  /* Four Y blocks */
-		/* NOTE: at end of line, the macroblock is handled as 420 */
-		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
+                /* NOTE: at end of line, the macroblock is handled as 420 */
+                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
                     data = y_ptr + (j * 8);
                 } else {
                     data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
                 }
-		linesize = s->picture.linesize[0];
+                linesize = s->picture.linesize[0];
             } else {      /* Cr and Cb blocks */
-	        /* don't ask Fabrice why they inverted Cb and Cr ! */
-	        data = s->picture.data[6 - j] + c_offset;
-		linesize = s->picture.linesize[6 - j];
-		if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
-		    do_edge_wrap = 1;
-	    }
-
-	    /* Everything is set up -- now just copy data -> DCT block */
-	    if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
-		uint8_t* d;
-		DCTELEM *b = block;
-	        for (i=0;i<8;i++) {
-		   d = data + 8 * linesize;
-		   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
+                /* don't ask Fabrice why they inverted Cb and Cr ! */
+                data = s->picture.data[6 - j] + c_offset;
+                linesize = s->picture.linesize[6 - j];
+                if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
+                    do_edge_wrap = 1;
+            }
+
+            /* Everything is set up -- now just copy data -> DCT block */
+            if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
+                uint8_t* d;
+                DCTELEM *b = block;
+                for (i=0;i<8;i++) {
+                   d = data + 8 * linesize;
+                   b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
-		   data += linesize;
-		   b += 8;
-		}
-	    } else {             /* Simple copy: 8x8 -> 8x8 */
-	        s->get_pixels(block, data, linesize);
-	    }
+                   data += linesize;
+                   b += 8;
+                }
+            } else {             /* Simple copy: 8x8 -> 8x8 */
+                s->get_pixels(block, data, linesize);
+            }
 
             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
                 enc_blk->dct_mode = dv_guess_dct_mode(block);
             else
                 enc_blk->dct_mode = 0;
-	    enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
-	    enc_blk->partial_bit_count = 0;
-	    enc_blk->partial_bit_buffer = 0;
-	    enc_blk->cur_ac = 0;
+            enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
+            enc_blk->partial_bit_count = 0;
+            enc_blk->partial_bit_buffer = 0;
+            enc_blk->cur_ac = 0;
 
-	    s->fdct[enc_blk->dct_mode](block);
+            s->fdct[enc_blk->dct_mode](block);
 
-	    dv_set_class_number(block, enc_blk,
-	                        enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
+            dv_set_class_number(block, enc_blk,
+                                enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct, j/4);
 
             init_put_bits(pb, ptr, block_sizes[j]/8);
-	    put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
-	    put_bits(pb, 1, enc_blk->dct_mode);
-	    put_bits(pb, 2, enc_blk->cno);
-
-	    vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
-	                   enc_blk->bit_size[2] + enc_blk->bit_size[3];
-	    ++enc_blk;
-	    ++pb;
-	    ptr += block_sizes[j]/8;
+            put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
+            put_bits(pb, 1, enc_blk->dct_mode);
+            put_bits(pb, 2, enc_blk->cno);
+
+            vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
+                           enc_blk->bit_size[2] + enc_blk->bit_size[3];
+            ++enc_blk;
+            ++pb;
+            ptr += block_sizes[j]/8;
         }
     }
 
@@ -898,7 +898,7 @@ static int dv_decode_mt(AVCodecContext *avctx, void* sl)
     DVVideoContext *s = avctx->priv_data;
     int slice = (size_t)sl;
     dv_decode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
-	                    &s->sys->video_place[slice*5]);
+                            &s->sys->video_place[slice*5]);
     return 0;
 }
 
@@ -907,7 +907,7 @@ static int dv_encode_mt(AVCodecContext *avctx, void* sl)
     DVVideoContext *s = avctx->priv_data;
     int slice = (size_t)sl;
     dv_encode_video_segment(s, &s->buf[((slice/27)*6+(slice/3)+slice*5+7)*80],
-	                    &s->sys->video_place[slice*5]);
+                            &s->sys->video_place[slice*5]);
     return 0;
 }
 
@@ -940,7 +940,7 @@ static int dvvideo_decode_frame(AVCodecContext *avctx,
 
     s->buf = buf;
     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
-	           s->sys->difseg_size * 27);
+                   s->sys->difseg_size * 27);
 
     emms_c();
 
@@ -958,7 +958,7 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
 
     s->sys = dv_codec_profile(c);
     if (!s->sys)
-	return -1;
+        return -1;
     if(buf_size < s->sys->frame_size)
         return -1;
 
@@ -969,7 +969,7 @@ static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
 
     s->buf = buf;
     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
-	       s->sys->difseg_size * 27);
+               s->sys->difseg_size * 27);
 
     emms_c();
     return s->sys->frame_size;