Whitespace: nuke CRLFs

Change-Id: I8b9fdf9875a8fcff4cb49a3357ce44f18108c2e7

2 files changed, 158 insertions, 158 deletions

diff --git a/vp8/encoder/encodeframe.c b/vp8/encoder/encodeframe.c
index e00154c80..1e0e1abc3 100644
--- a/vp8/encoder/encodeframe.c
+++ b/vp8/encoder/encodeframe.c
@@ -228,69 +228,69 @@ void vp8cx_init_quantizer(VP8_COMP *cpi)
     }
 }
 #else
-void vp8cx_init_quantizer(VP8_COMP *cpi)

-{

-    int r, c;

-    int i;

-    int quant_val;

-    int Q;

-

-    int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};

-

-    for (Q = 0; Q < QINDEX_RANGE; Q++)

-    {

-        // dc values

-        quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);

-        cpi->Y1quant[Q][0][0] = (1 << 16) / quant_val;

-        cpi->Y1zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

-        cpi->Y1round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;

-        cpi->common.Y1dequant[Q][0][0] = quant_val;

-        cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;

-

-        quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);

-        cpi->Y2quant[Q][0][0] = (1 << 16) / quant_val;

-        cpi->Y2zbin[Q][0][0] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;

-        cpi->Y2round[Q][0][0] = (qrounding_factors_y2[Q] * quant_val) >> 7;

-        cpi->common.Y2dequant[Q][0][0] = quant_val;

-        cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;

-

-        quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);

-        cpi->UVquant[Q][0][0] = (1 << 16) / quant_val;

-        cpi->UVzbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;

-        cpi->UVround[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;

-        cpi->common.UVdequant[Q][0][0] = quant_val;

-        cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;

-

-        // all the ac values = ;

-        for (i = 1; i < 16; i++)

-        {

-            int rc = vp8_default_zig_zag1d[i];

-            r = (rc >> 2);

-            c = (rc & 3);

-

-            quant_val = vp8_ac_yquant(Q);

-            cpi->Y1quant[Q][r][c] = (1 << 16) / quant_val;

-            cpi->Y1zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

-            cpi->Y1round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;

-            cpi->common.Y1dequant[Q][r][c] = quant_val;

-            cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;

-

-            quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);

-            cpi->Y2quant[Q][r][c] = (1 << 16) / quant_val;

-            cpi->Y2zbin[Q][r][c] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;

-            cpi->Y2round[Q][r][c] = (qrounding_factors_y2[Q] * quant_val) >> 7;

-            cpi->common.Y2dequant[Q][r][c] = quant_val;

-            cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;

-

-            quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);

-            cpi->UVquant[Q][r][c] = (1 << 16) / quant_val;

-            cpi->UVzbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;

-            cpi->UVround[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;

-            cpi->common.UVdequant[Q][r][c] = quant_val;

-            cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;

-        }

-    }

-}

+void vp8cx_init_quantizer(VP8_COMP *cpi)
+{
+    int r, c;
+    int i;
+    int quant_val;
+    int Q;
+
+    int zbin_boost[16] = {0, 0, 8, 10, 12, 14, 16, 20, 24, 28, 32, 36, 40, 44, 44, 44};
+
+    for (Q = 0; Q < QINDEX_RANGE; Q++)
+    {
+        // dc values
+        quant_val = vp8_dc_quant(Q, cpi->common.y1dc_delta_q);
+        cpi->Y1quant[Q][0][0] = (1 << 16) / quant_val;
+        cpi->Y1zbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
+        cpi->Y1round[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
+        cpi->common.Y1dequant[Q][0][0] = quant_val;
+        cpi->zrun_zbin_boost_y1[Q][0] = (quant_val * zbin_boost[0]) >> 7;
+
+        quant_val = vp8_dc2quant(Q, cpi->common.y2dc_delta_q);
+        cpi->Y2quant[Q][0][0] = (1 << 16) / quant_val;
+        cpi->Y2zbin[Q][0][0] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
+        cpi->Y2round[Q][0][0] = (qrounding_factors_y2[Q] * quant_val) >> 7;
+        cpi->common.Y2dequant[Q][0][0] = quant_val;
+        cpi->zrun_zbin_boost_y2[Q][0] = (quant_val * zbin_boost[0]) >> 7;
+
+        quant_val = vp8_dc_uv_quant(Q, cpi->common.uvdc_delta_q);
+        cpi->UVquant[Q][0][0] = (1 << 16) / quant_val;
+        cpi->UVzbin[Q][0][0] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;;
+        cpi->UVround[Q][0][0] = (qrounding_factors[Q] * quant_val) >> 7;
+        cpi->common.UVdequant[Q][0][0] = quant_val;
+        cpi->zrun_zbin_boost_uv[Q][0] = (quant_val * zbin_boost[0]) >> 7;
+
+        // all the ac values = ;
+        for (i = 1; i < 16; i++)
+        {
+            int rc = vp8_default_zig_zag1d[i];
+            r = (rc >> 2);
+            c = (rc & 3);
+
+            quant_val = vp8_ac_yquant(Q);
+            cpi->Y1quant[Q][r][c] = (1 << 16) / quant_val;
+            cpi->Y1zbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
+            cpi->Y1round[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
+            cpi->common.Y1dequant[Q][r][c] = quant_val;
+            cpi->zrun_zbin_boost_y1[Q][i] = (quant_val * zbin_boost[i]) >> 7;
+
+            quant_val = vp8_ac2quant(Q, cpi->common.y2ac_delta_q);
+            cpi->Y2quant[Q][r][c] = (1 << 16) / quant_val;
+            cpi->Y2zbin[Q][r][c] = ((qzbin_factors_y2[Q] * quant_val) + 64) >> 7;
+            cpi->Y2round[Q][r][c] = (qrounding_factors_y2[Q] * quant_val) >> 7;
+            cpi->common.Y2dequant[Q][r][c] = quant_val;
+            cpi->zrun_zbin_boost_y2[Q][i] = (quant_val * zbin_boost[i]) >> 7;
+
+            quant_val = vp8_ac_uv_quant(Q, cpi->common.uvac_delta_q);
+            cpi->UVquant[Q][r][c] = (1 << 16) / quant_val;
+            cpi->UVzbin[Q][r][c] = ((qzbin_factors[Q] * quant_val) + 64) >> 7;
+            cpi->UVround[Q][r][c] = (qrounding_factors[Q] * quant_val) >> 7;
+            cpi->common.UVdequant[Q][r][c] = quant_val;
+            cpi->zrun_zbin_boost_uv[Q][i] = (quant_val * zbin_boost[i]) >> 7;
+        }
+    }
+}
 #endif
 void vp8cx_mb_init_quantizer(VP8_COMP *cpi, MACROBLOCK *x)
 {
diff --git a/vp8/encoder/quantize.c b/vp8/encoder/quantize.c
index 2ea16d8f0..f495940b3 100644
--- a/vp8/encoder/quantize.c
+++ b/vp8/encoder/quantize.c
@@ -119,101 +119,101 @@ void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d)
     d->eob = eob + 1;
 }
 #else
-void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d)

-{

-    int i, rc, eob;

-    int zbin;

-    int x, y, z, sz;

-    short *coeff_ptr  = &b->coeff[0];

-    short *zbin_ptr   = &b->zbin[0][0];

-    short *round_ptr  = &b->round[0][0];

-    short *quant_ptr  = &b->quant[0][0];

-    short *qcoeff_ptr = d->qcoeff;

-    short *dqcoeff_ptr = d->dqcoeff;

-    short *dequant_ptr = &d->dequant[0][0];

-

-    vpx_memset(qcoeff_ptr, 0, 32);

-    vpx_memset(dqcoeff_ptr, 0, 32);

-

-    eob = -1;

-

-    for (i = 0; i < 16; i++)

-    {

-        rc   = vp8_default_zig_zag1d[i];

-        z    = coeff_ptr[rc];

-        zbin = zbin_ptr[rc] ;

-

-        sz = (z >> 31);                                 // sign of z

-        x  = (z ^ sz) - sz;                             // x = abs(z)

-

-        if (x >= zbin)

-        {

-            y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)

-            x  = (y ^ sz) - sz;                         // get the sign back

-            qcoeff_ptr[rc] = x;                          // write to destination

-            dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value

-

-            if (y)

-            {

-                eob = i;                                // last nonzero coeffs

-            }

-        }

-    }

-    d->eob = eob + 1;

-}

-

-void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d)

-{

-    int i, rc, eob;

-    int zbin;

-    int x, y, z, sz;

-    short *zbin_boost_ptr = &b->zrun_zbin_boost[0];

-    short *coeff_ptr  = &b->coeff[0];

-    short *zbin_ptr   = &b->zbin[0][0];

-    short *round_ptr  = &b->round[0][0];

-    short *quant_ptr  = &b->quant[0][0];

-    short *qcoeff_ptr = d->qcoeff;

-    short *dqcoeff_ptr = d->dqcoeff;

-    short *dequant_ptr = &d->dequant[0][0];

-    short zbin_oq_value = b->zbin_extra;

-

-    vpx_memset(qcoeff_ptr, 0, 32);

-    vpx_memset(dqcoeff_ptr, 0, 32);

-

-    eob = -1;

-

-    for (i = 0; i < 16; i++)

-    {

-        rc   = vp8_default_zig_zag1d[i];

-        z    = coeff_ptr[rc];

-

-        //if ( i == 0 )

-        //    zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value/2;

-        //else

-        zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value;

-

-        zbin_boost_ptr ++;

-        sz = (z >> 31);                                 // sign of z

-        x  = (z ^ sz) - sz;                             // x = abs(z)

-

-        if (x >= zbin)

-        {

-            y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)

-            x  = (y ^ sz) - sz;                         // get the sign back

-            qcoeff_ptr[rc]  = x;                         // write to destination

-            dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value

-

-            if (y)

-            {

-                eob = i;                                // last nonzero coeffs

-                zbin_boost_ptr = &b->zrun_zbin_boost[0];    // reset zero runlength

-            }

-        }

-    }

-

-    d->eob = eob + 1;

-}

-

+void vp8_fast_quantize_b_c(BLOCK *b, BLOCKD *d)
+{
+    int i, rc, eob;
+    int zbin;
+    int x, y, z, sz;
+    short *coeff_ptr  = &b->coeff[0];
+    short *zbin_ptr   = &b->zbin[0][0];
+    short *round_ptr  = &b->round[0][0];
+    short *quant_ptr  = &b->quant[0][0];
+    short *qcoeff_ptr = d->qcoeff;
+    short *dqcoeff_ptr = d->dqcoeff;
+    short *dequant_ptr = &d->dequant[0][0];
+
+    vpx_memset(qcoeff_ptr, 0, 32);
+    vpx_memset(dqcoeff_ptr, 0, 32);
+
+    eob = -1;
+
+    for (i = 0; i < 16; i++)
+    {
+        rc   = vp8_default_zig_zag1d[i];
+        z    = coeff_ptr[rc];
+        zbin = zbin_ptr[rc] ;
+
+        sz = (z >> 31);                                 // sign of z
+        x  = (z ^ sz) - sz;                             // x = abs(z)
+
+        if (x >= zbin)
+        {
+            y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)
+            x  = (y ^ sz) - sz;                         // get the sign back
+            qcoeff_ptr[rc] = x;                          // write to destination
+            dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
+
+            if (y)
+            {
+                eob = i;                                // last nonzero coeffs
+            }
+        }
+    }
+    d->eob = eob + 1;
+}
+
+void vp8_regular_quantize_b(BLOCK *b, BLOCKD *d)
+{
+    int i, rc, eob;
+    int zbin;
+    int x, y, z, sz;
+    short *zbin_boost_ptr = &b->zrun_zbin_boost[0];
+    short *coeff_ptr  = &b->coeff[0];
+    short *zbin_ptr   = &b->zbin[0][0];
+    short *round_ptr  = &b->round[0][0];
+    short *quant_ptr  = &b->quant[0][0];
+    short *qcoeff_ptr = d->qcoeff;
+    short *dqcoeff_ptr = d->dqcoeff;
+    short *dequant_ptr = &d->dequant[0][0];
+    short zbin_oq_value = b->zbin_extra;
+
+    vpx_memset(qcoeff_ptr, 0, 32);
+    vpx_memset(dqcoeff_ptr, 0, 32);
+
+    eob = -1;
+
+    for (i = 0; i < 16; i++)
+    {
+        rc   = vp8_default_zig_zag1d[i];
+        z    = coeff_ptr[rc];
+
+        //if ( i == 0 )
+        //    zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value/2;
+        //else
+        zbin = zbin_ptr[rc] + *zbin_boost_ptr + zbin_oq_value;
+
+        zbin_boost_ptr ++;
+        sz = (z >> 31);                                 // sign of z
+        x  = (z ^ sz) - sz;                             // x = abs(z)
+
+        if (x >= zbin)
+        {
+            y  = ((x + round_ptr[rc]) * quant_ptr[rc]) >> 16; // quantize (x)
+            x  = (y ^ sz) - sz;                         // get the sign back
+            qcoeff_ptr[rc]  = x;                         // write to destination
+            dqcoeff_ptr[rc] = x * dequant_ptr[rc];        // dequantized value
+
+            if (y)
+            {
+                eob = i;                                // last nonzero coeffs
+                zbin_boost_ptr = &b->zrun_zbin_boost[0];    // reset zero runlength
+            }
+        }
+    }
+
+    d->eob = eob + 1;
+}
+
 #endif
 
 /* Perform regular quantization, with unbiased rounding and no zero bin. */