public void writeDataScaled(byte[][,] raster, int componentIndex, BlockUpsamplingMode mode)
{
int x = 0, y = 0, lastblockheight = 0, incrementblock = 0;
int blockIdx = 0;
int w = raster[0].GetLength(0);
//h = raster[0].GetLength(1);
// Keep looping through all of the blocks until there are no more.
while (blockIdx < scanDecoded.Count)
{
int blockwidth = 0;
int blockheight = 0;
if (x >= w)
{
x = 0; y += incrementblock;
}
// Loop through the horizontal component blocks of the MCU first
// then for each horizontal line write out all of the vertical
// components
for (int factorVIndex = 0; factorVIndex < factorV; factorVIndex++)
{
blockwidth = 0;
for (int factorHIndex = 0; factorHIndex < factorH; factorHIndex++)
{
// Captures the width of this block so we can increment the X coordinate
byte[,] blockdata = scanDecoded[blockIdx++];
// Writes the data at the specific X and Y coordinate of this component
writeBlockScaled(raster, blockdata, componentIndex, x, y, mode);
blockwidth += blockdata.GetLength(1) * factorUpH;
x += blockdata.GetLength(1) * factorUpH;
blockheight = blockdata.GetLength(0) * factorUpV;
}
y += blockheight;
x -= blockwidth;
lastblockheight += blockheight;
}
y -= lastblockheight;
incrementblock = lastblockheight;
lastblockheight = 0;
x += blockwidth;
}
}
public void writeDataScaled(byte[][,] raster, int componentIndex, BlockUpsamplingMode mode)
{
int x = 0;
int y = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int length = raster[0].GetLength(0);
int num7 = raster[0].GetLength(1);
while (num5 < this.scanDecoded.Count)
{
int num8 = 0;
int num9 = 0;
if (x >= length)
{
x = 0;
y += num4;
}
for (int i = 0; i < this.factorV; i++)
{
num8 = 0;
for (int j = 0; j < this.factorH; j++)
{
byte[,] blockdata = this.scanDecoded[num5++];
this.writeBlockScaled(raster, blockdata, componentIndex, x, y, mode);
num8 += blockdata.GetLength(1) * this.factorUpH;
x += blockdata.GetLength(1) * this.factorUpH;
num9 = blockdata.GetLength(0) * this.factorUpV;
}
y += num9;
x -= num8;
num3 += num9;
}
y -= num3;
num4 = num3;
num3 = 0;
x += num8;
}
}
public void writeDataScaled(byte[][,] raster, int componentIndex, BlockUpsamplingMode mode)
{
int num = 0;
int num2 = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int length = raster[0].GetLength(0);
while (num5 < scanDecoded.Count)
{
int num6 = 0;
int num7 = 0;
if (num >= length)
{
num = 0;
num2 += num4;
}
for (int i = 0; i < factorV; i++)
{
num6 = 0;
for (int j = 0; j < factorH; j++)
{
byte[,] array = scanDecoded[num5++];
writeBlockScaled(raster, array, componentIndex, num, num2, mode);
num6 += array.GetLength(1) * factorUpH;
num += array.GetLength(1) * factorUpH;
num7 = array.GetLength(0) * factorUpV;
}
num2 += num7;
num -= num6;
num3 += num7;
}
num2 -= num3;
num4 = num3;
num3 = 0;
num += num6;
}
}
private void writeBlockScaled(byte[][,] raster, byte[,] blockdata, int compIndex, int x, int y, BlockUpsamplingMode mode)
{
int w = raster[0].GetLength(0),
h = raster[0].GetLength(1);
int factorUpVertical = factorUpV,
factorUpHorizontal = factorUpH;
int oldV = blockdata.GetLength(0),
oldH = blockdata.GetLength(1),
newV = oldV * factorUpVertical,
newH = oldH * factorUpHorizontal;
byte[,] comp = raster[compIndex];
// Blocks may spill over the frame so we bound by the frame size
int yMax = newV; if ((y + yMax) > h) yMax = h - y;
int xMax = newH; if ((x + xMax) > w) xMax = w - x;
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
#region Upsampling by repeating values
// Special case 1: No scale-up
if (factorUpVertical == 1 && factorUpHorizontal == 1)
{
for (int u = 0; u < xMax; u++)
for (int v = 0; v < yMax; v++)
comp[u + x, y + v] = blockdata[v, u];
}
// Special case 2: Perform scale-up 4 pixels at a time
else if (factorUpHorizontal == 2 &&
factorUpVertical == 2 &&
xMax == newH && yMax == newV)
{
for (int src_u = 0; src_u < oldH; src_u++)
{
int bx = src_u * 2 + x;
for ( int src_v = 0; src_v < oldV; src_v++)
{
byte val = blockdata[src_v, src_u];
int by = src_v * 2 + y;
comp[bx, by] = val;
comp[bx, by + 1] = val;
comp[bx + 1, by] = val;
comp[bx + 1, by + 1] = val;
}
}
}
else
{
/* Perform scaling (Box filter) */
for (int u = 0; u < xMax; u++)
{
int src_u = u / factorUpHorizontal;
for (int v = 0; v < yMax; v++)
{
int src_v = v / factorUpVertical;
comp[u + x, y + v] = blockdata[src_v, src_u];
}
}
}
#endregion
break;
// JRP 4/7/08 -- This mode is disabled temporarily as it needs to be fixed after
// recent performance tweaks.
// It can produce slightly better (less blocky) decodings.
//case BlockUpsamplingMode.Interpolate:
// #region Upsampling by interpolation
// for (int u = 0; u < newH; u++)
// {
// for (int v = 0; v < newV; v++)
// {
// int val = 0;
// for (int x = 0; x < factorUpHorizontal; x++)
// {
// int src_u = (u + x) / factorUpHorizontal;
// if (src_u >= oldH) src_u = oldH - 1;
// for (int y = 0; y < factorUpVertical; y++)
// {
// int src_v = (v + y) / factorUpVertical;
// if (src_v >= oldV) src_v = oldV - 1;
// val += src[src_v, src_u];
// }
// }
// dest[v, u] = (byte)(val / (factorUpHorizontal * factorUpVertical));
// }
// }
// #endregion
// break;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
}
public void writeDataScaled(byte[][,] raster, int componentIndex, BlockUpsamplingMode mode)
{
int x = 0, y = 0, lastblockheight = 0, incrementblock = 0;
int blockIdx = 0;
int w = raster[0].GetLength(0),
h = raster[0].GetLength(1);
// Keep looping through all of the blocks until there are no more.
while (blockIdx < scanDecoded.Count)
{
int blockwidth = 0;
int blockheight = 0;
if (x >= w) { x = 0; y += incrementblock; }
// Loop through the horizontal component blocks of the MCU first
// then for each horizontal line write out all of the vertical
// components
for (int factorVIndex = 0; factorVIndex < factorV; factorVIndex++)
{
blockwidth = 0;
for (int factorHIndex = 0; factorHIndex < factorH; factorHIndex++)
{
// Captures the width of this block so we can increment the X coordinate
byte[,] blockdata = scanDecoded[blockIdx++];
// Writes the data at the specific X and Y coordinate of this component
writeBlockScaled(raster, blockdata, componentIndex, x, y, mode);
blockwidth += blockdata.GetLength(1) * factorUpH;
x += blockdata.GetLength(1) * factorUpH;
blockheight = blockdata.GetLength(0) * factorUpV;
}
y += blockheight;
x -= blockwidth;
lastblockheight += blockheight;
}
y -= lastblockheight;
incrementblock = lastblockheight;
lastblockheight = 0;
x += blockwidth;
}
}
/// <summary>
/// Stretches components as needed to normalize the size of all components.
/// For example, in a 2x1 (4:2:2) sequence, the Cr and Cb channels will be
/// scaled vertically by a factor of 2.
/// </summary>
public void scaleByFactors( BlockUpsamplingMode mode )
{
int factorUpVertical = factorUpV,
factorUpHorizontal = factorUpH;
if (factorUpVertical == 1 && factorUpHorizontal == 1) return;
for (int i = 0; i < scanDecoded.Count; i++)
{
byte[,] src = scanDecoded[i];
int oldV = src.GetLength(0),
oldH = src.GetLength(1),
newV = oldV * factorUpVertical,
newH = oldH * factorUpHorizontal;
byte[,] dest = new byte[newV, newH];
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
#region Upsampling by repeating values
/* Perform scaling (Box filter) */
for (int u = 0; u < newH; u++)
{
int src_u = u / factorUpHorizontal;
for (int v = 0; v < newV; v++)
{
int src_v = v / factorUpVertical;
dest[v, u] = src[src_v, src_u];
}
}
#endregion
break;
case BlockUpsamplingMode.Interpolate:
#region Upsampling by interpolation
for (int u = 0; u < newH; u++)
{
for (int v = 0; v < newV; v++)
{
int val = 0;
for (int x = 0; x < factorUpHorizontal; x++)
{
int src_u = (u + x) / factorUpHorizontal;
if (src_u >= oldH) src_u = oldH - 1;
for (int y = 0; y < factorUpVertical; y++)
{
int src_v = (v + y) / factorUpVertical;
if (src_v >= oldV) src_v = oldV - 1;
val += src[src_v, src_u];
}
}
dest[v, u] = (byte)(val / (factorUpHorizontal * factorUpVertical));
}
}
#endregion
break;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
scanDecoded[i] = dest;
}
}
private void writeBlockScaled(byte[][,] raster, byte[,] blockdata, int compIndex, int x, int y, BlockUpsamplingMode mode)
{
int w = raster[0].GetLength(0),
h = raster[0].GetLength(1);
int factorUpVertical = factorUpV,
factorUpHorizontal = factorUpH;
int oldV = blockdata.GetLength(0),
oldH = blockdata.GetLength(1),
newV = oldV * factorUpVertical,
newH = oldH * factorUpHorizontal;
byte[,] comp = raster[compIndex];
// Blocks may spill over the frame so we bound by the frame size
int yMax = newV; if ((y + yMax) > h)
{
yMax = h - y;
}
int xMax = newH; if ((x + xMax) > w)
{
xMax = w - x;
}
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
#region Upsampling by repeating values
// Special case 1: No scale-up
if (factorUpVertical == 1 && factorUpHorizontal == 1)
{
for (int u = 0; u < xMax; u++)
{
for (int v = 0; v < yMax; v++)
{
comp[u + x, y + v] = blockdata[v, u];
}
}
}
// Special case 2: Perform scale-up 4 pixels at a time
else if (factorUpHorizontal == 2 &&
factorUpVertical == 2 &&
xMax == newH && yMax == newV)
{
for (int src_u = 0; src_u < oldH; src_u++)
{
int bx = src_u * 2 + x;
for (int src_v = 0; src_v < oldV; src_v++)
{
byte val = blockdata[src_v, src_u];
int by = src_v * 2 + y;
comp[bx, by] = val;
comp[bx, by + 1] = val;
comp[bx + 1, by] = val;
comp[bx + 1, by + 1] = val;
}
}
}
else
{
/* Perform scaling (Box filter) */
for (int u = 0; u < xMax; u++)
{
int src_u = u / factorUpHorizontal;
for (int v = 0; v < yMax; v++)
{
int src_v = v / factorUpVertical;
comp[u + x, y + v] = blockdata[src_v, src_u];
}
}
}
#endregion
break;
// JRP 4/7/08 -- This mode is disabled temporarily as it needs to be fixed after
// recent performance tweaks.
// It can produce slightly better (less blocky) decodings.
//case BlockUpsamplingMode.Interpolate:
// #region Upsampling by interpolation
// for (int u = 0; u < newH; u++)
// {
// for (int v = 0; v < newV; v++)
// {
// int val = 0;
// for (int x = 0; x < factorUpHorizontal; x++)
// {
// int src_u = (u + x) / factorUpHorizontal;
// if (src_u >= oldH) src_u = oldH - 1;
// for (int y = 0; y < factorUpVertical; y++)
// {
// int src_v = (v + y) / factorUpVertical;
// if (src_v >= oldV) src_v = oldV - 1;
// val += src[src_v, src_u];
// }
// }
// dest[v, u] = (byte)(val / (factorUpHorizontal * factorUpVertical));
// }
// }
// #endregion
// break;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
}
/// <summary>
/// Stretches components as needed to normalize the size of all components.
/// For example, in a 2x1 (4:2:2) sequence, the Cr and Cb channels will be
/// scaled vertically by a factor of 2.
/// </summary>
public void scaleByFactors(BlockUpsamplingMode mode)
{
int factorUpVertical = factorUpV,
factorUpHorizontal = factorUpH;
if (factorUpVertical == 1 && factorUpHorizontal == 1)
{
return;
}
for (int i = 0; i < scanDecoded.Count; i++)
{
byte[,] src = scanDecoded[i];
int oldV = src.GetLength(0),
oldH = src.GetLength(1),
newV = oldV * factorUpVertical,
newH = oldH * factorUpHorizontal;
byte[,] dest = new byte[newV, newH];
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
#region Upsampling by repeating values
/* Perform scaling (Box filter) */
for (int u = 0; u < newH; u++)
{
int src_u = u / factorUpHorizontal;
for (int v = 0; v < newV; v++)
{
int src_v = v / factorUpVertical;
dest[v, u] = src[src_v, src_u];
}
}
#endregion
break;
case BlockUpsamplingMode.Interpolate:
#region Upsampling by interpolation
for (int u = 0; u < newH; u++)
{
for (int v = 0; v < newV; v++)
{
int val = 0;
for (int x = 0; x < factorUpHorizontal; x++)
{
int src_u = (u + x) / factorUpHorizontal;
if (src_u >= oldH)
{
src_u = oldH - 1;
}
for (int y = 0; y < factorUpVertical; y++)
{
int src_v = (v + y) / factorUpVertical;
if (src_v >= oldV)
{
src_v = oldV - 1;
}
val += src[src_v, src_u];
}
}
dest[v, u] = (byte)(val / (factorUpHorizontal * factorUpVertical));
}
}
#endregion
break;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
scanDecoded[i] = dest;
}
}
public void writeBlockScaled(byte[][,] raster, byte[,] blockdata, int compIndex, int x, int y, BlockUpsamplingMode mode)
{
int length = raster[0].GetLength(0);
int length2 = raster[0].GetLength(1);
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
int length3 = blockdata.GetLength(0);
int length4 = blockdata.GetLength(1);
int num = length3 * factorUpV;
int num2 = length4 * factorUpH;
byte[,] array = raster[compIndex];
int num3 = num;
if (y + num3 > length2)
{
num3 = length2 - y;
}
int num4 = num2;
if (x + num4 > length)
{
num4 = length - x;
}
if (mode == BlockUpsamplingMode.BoxFilter)
{
if (factorUpV == 1 && factorUpH == 1)
{
for (int i = 0; i < num4; i++)
{
for (int j = 0; j < num3; j++)
{
array[i + x, y + j] = blockdata[j, i];
}
}
return;
}
if (factorUpH == 2 && factorUpV == 2 && num4 == num2 && num3 == num)
{
for (int k = 0; k < length4; k++)
{
int num5 = k * 2 + x;
for (int l = 0; l < length3; l++)
{
byte b = blockdata[l, k];
int num6 = l * 2 + y;
array[num5, num6] = b;
array[num5, num6 + 1] = b;
array[num5 + 1, num6] = b;
array[num5 + 1, num6 + 1] = b;
}
}
return;
}
for (int m = 0; m < num4; m++)
{
int num7 = m / factorUpH;
for (int n = 0; n < num3; n++)
{
int num8 = n / factorUpV;
array[m + x, y + n] = blockdata[num8, num7];
}
}
return;
}
throw new ArgumentException("Upsampling mode not supported.");
}
public void scaleByFactors(BlockUpsamplingMode mode)
{
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
if (factorUpV == 1 && factorUpH == 1)
{
return;
}
for (int i = 0; i < scanDecoded.Count; i++)
{
byte[,] array = scanDecoded[i];
int length = array.GetLength(0);
int length2 = array.GetLength(1);
int num = length * factorUpV;
int num2 = length2 * factorUpH;
byte[,] array2 = new byte[num, num2];
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
{
for (int n = 0; n < num2; n++)
{
int num6 = n / factorUpH;
for (int num7 = 0; num7 < num; num7++)
{
int num8 = num7 / factorUpV;
array2[num7, n] = array[num8, num6];
}
}
break;
}
case BlockUpsamplingMode.Interpolate:
{
for (int j = 0; j < num2; j++)
{
for (int k = 0; k < num; k++)
{
int num3 = 0;
for (int l = 0; l < factorUpH; l++)
{
int num4 = (j + l) / factorUpH;
if (num4 >= length2)
{
num4 = length2 - 1;
}
for (int m = 0; m < factorUpV; m++)
{
int num5 = (k + m) / factorUpV;
if (num5 >= length)
{
num5 = length - 1;
}
num3 += array[num5, num4];
}
}
array2[k, j] = (byte)(num3 / (factorUpH * factorUpV));
}
}
break;
}
default:
throw new ArgumentException("Upsampling mode not supported.");
}
scanDecoded[i] = array2;
}
}
private void writeBlockScaled(byte[][,] raster, byte[,] blockdata, int compIndex, int x, int y, BlockUpsamplingMode mode)
{
int num11;
int num12;
int length = raster[0].GetLength(0);
int num2 = raster[0].GetLength(1);
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
int num5 = blockdata.GetLength(0);
int num6 = blockdata.GetLength(1);
int num7 = num5 * factorUpV;
int num8 = num6 * factorUpH;
byte[,] buffer = raster[compIndex];
int num9 = num7;
if ((y + num9) > num2)
{
num9 = num2 - y;
}
int num10 = num8;
if ((x + num10) > length)
{
num10 = length - x;
}
if (mode != BlockUpsamplingMode.BoxFilter)
{
throw new ArgumentException("Upsampling mode not supported.");
}
if ((factorUpV == 1) && (factorUpH == 1))
{
for (num11 = 0; num11 < num10; num11++)
{
num12 = 0;
while (num12 < num9)
{
buffer[num11 + x, y + num12] = blockdata[num12, num11];
num12++;
}
}
}
else
{
int num13;
int num15;
if ((((factorUpH == 2) && (factorUpV == 2)) && (num10 == num8)) && (num9 == num7))
{
num13 = 0;
while (num13 < num6)
{
int num14 = (num13 * 2) + x;
num15 = 0;
while (num15 < num5)
{
byte num16 = blockdata[num15, num13];
int num17 = (num15 * 2) + y;
buffer[num14, num17] = num16;
buffer[num14, num17 + 1] = num16;
buffer[num14 + 1, num17] = num16;
buffer[num14 + 1, num17 + 1] = num16;
num15++;
}
num13++;
}
}
else
{
for (num11 = 0; num11 < num10; num11++)
{
num13 = num11 / factorUpH;
for (num12 = 0; num12 < num9; num12++)
{
num15 = num12 / factorUpV;
buffer[num11 + x, y + num12] = blockdata[num15, num13];
}
}
}
}
}
public void scaleByFactors(BlockUpsamplingMode mode)
{
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
if ((factorUpV != 1) || (factorUpH != 1))
{
for (int i = 0; i < this.scanDecoded.Count; i++)
{
int num8;
int num9;
int num11;
byte[,] buffer = this.scanDecoded[i];
int length = buffer.GetLength(0);
int num5 = buffer.GetLength(1);
int num6 = length * factorUpV;
int num7 = num5 * factorUpH;
byte[,] buffer2 = new byte[num6, num7];
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
num8 = 0;
goto Label_00C4;
case BlockUpsamplingMode.Interpolate:
num8 = 0;
goto Label_018E;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
Label_0082:
num9 = num8 / factorUpH;
int num10 = 0;
while (num10 < num6)
{
num11 = num10 / factorUpV;
buffer2[num10, num8] = buffer[num11, num9];
num10++;
}
num8++;
Label_00C4:
if (num8 < num7)
{
goto Label_0082;
}
goto Label_01AA;
Label_00DD:
num10 = 0;
while (num10 < num6)
{
int num12 = 0;
for (int j = 0; j < factorUpH; j++)
{
num9 = (num8 + j) / factorUpH;
if (num9 >= num5)
{
num9 = num5 - 1;
}
for (int k = 0; k < factorUpV; k++)
{
num11 = (num10 + k) / factorUpV;
if (num11 >= length)
{
num11 = length - 1;
}
num12 += buffer[num11, num9];
}
}
buffer2[num10, num8] = (byte)(num12 / (factorUpH * factorUpV));
num10++;
}
num8++;
Label_018E:
if (num8 < num7)
{
goto Label_00DD;
}
Label_01AA:
this.scanDecoded[i] = buffer2;
}
}
}
public void writeDataScaled(byte[][,] raster, int componentIndex, BlockUpsamplingMode mode)
{
int x = 0;
int y = 0;
int num3 = 0;
int num4 = 0;
int num5 = 0;
int length = raster[0].GetLength(0);
int num7 = raster[0].GetLength(1);
while (num5 < this.scanDecoded.Count)
{
int num8 = 0;
int num9 = 0;
if (x >= length)
{
x = 0;
y += num4;
}
for (int i = 0; i < this.factorV; i++)
{
num8 = 0;
for (int j = 0; j < this.factorH; j++)
{
byte[,] blockdata = this.scanDecoded[num5++];
this.writeBlockScaled(raster, blockdata, componentIndex, x, y, mode);
num8 += blockdata.GetLength(1) * this.factorUpH;
x += blockdata.GetLength(1) * this.factorUpH;
num9 = blockdata.GetLength(0) * this.factorUpV;
}
y += num9;
x -= num8;
num3 += num9;
}
y -= num3;
num4 = num3;
num3 = 0;
x += num8;
}
}
private void writeBlockScaled(byte[][,] raster, byte[,] blockdata, int compIndex, int x, int y, BlockUpsamplingMode mode)
{
int num11;
int num12;
int length = raster[0].GetLength(0);
int num2 = raster[0].GetLength(1);
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
int num5 = blockdata.GetLength(0);
int num6 = blockdata.GetLength(1);
int num7 = num5 * factorUpV;
int num8 = num6 * factorUpH;
byte[,] buffer = raster[compIndex];
int num9 = num7;
if ((y + num9) > num2)
{
num9 = num2 - y;
}
int num10 = num8;
if ((x + num10) > length)
{
num10 = length - x;
}
if (mode != BlockUpsamplingMode.BoxFilter)
{
throw new ArgumentException("Upsampling mode not supported.");
}
if ((factorUpV == 1) && (factorUpH == 1))
{
for (num11 = 0; num11 < num10; num11++)
{
num12 = 0;
while (num12 < num9)
{
buffer[num11 + x, y + num12] = blockdata[num12, num11];
num12++;
}
}
}
else
{
int num13;
int num15;
if ((((factorUpH == 2) && (factorUpV == 2)) && (num10 == num8)) && (num9 == num7))
{
num13 = 0;
while (num13 < num6)
{
int num14 = (num13 * 2) + x;
num15 = 0;
while (num15 < num5)
{
byte num16 = blockdata[num15, num13];
int num17 = (num15 * 2) + y;
buffer[num14, num17] = num16;
buffer[num14, num17 + 1] = num16;
buffer[num14 + 1, num17] = num16;
buffer[num14 + 1, num17 + 1] = num16;
num15++;
}
num13++;
}
}
else
{
for (num11 = 0; num11 < num10; num11++)
{
num13 = num11 / factorUpH;
for (num12 = 0; num12 < num9; num12++)
{
num15 = num12 / factorUpV;
buffer[num11 + x, y + num12] = blockdata[num15, num13];
}
}
}
}
}
public void scaleByFactors(BlockUpsamplingMode mode)
{
int factorUpV = this.factorUpV;
int factorUpH = this.factorUpH;
if ((factorUpV != 1) || (factorUpH != 1))
{
for (int i = 0; i < this.scanDecoded.Count; i++)
{
int num8;
int num9;
int num11;
byte[,] buffer = this.scanDecoded[i];
int length = buffer.GetLength(0);
int num5 = buffer.GetLength(1);
int num6 = length * factorUpV;
int num7 = num5 * factorUpH;
byte[,] buffer2 = new byte[num6, num7];
switch (mode)
{
case BlockUpsamplingMode.BoxFilter:
num8 = 0;
goto Label_00C4;
case BlockUpsamplingMode.Interpolate:
num8 = 0;
goto Label_018E;
default:
throw new ArgumentException("Upsampling mode not supported.");
}
Label_0082:
num9 = num8 / factorUpH;
int num10 = 0;
while (num10 < num6)
{
num11 = num10 / factorUpV;
buffer2[num10, num8] = buffer[num11, num9];
num10++;
}
num8++;
Label_00C4:
if (num8 < num7)
{
goto Label_0082;
}
goto Label_01AA;
Label_00DD:
num10 = 0;
while (num10 < num6)
{
int num12 = 0;
for (int j = 0; j < factorUpH; j++)
{
num9 = (num8 + j) / factorUpH;
if (num9 >= num5)
{
num9 = num5 - 1;
}
for (int k = 0; k < factorUpV; k++)
{
num11 = (num10 + k) / factorUpV;
if (num11 >= length)
{
num11 = length - 1;
}
num12 += buffer[num11, num9];
}
}
buffer2[num10, num8] = (byte) (num12 / (factorUpH * factorUpV));
num10++;
}
num8++;
Label_018E:
if (num8 < num7)
{
goto Label_00DD;
}
Label_01AA:
this.scanDecoded[i] = buffer2;
}
}
}
){kind=link}