/**
Support function for bicubic interpolation.
*/
private static function A(x:Number):Number
{
var p0:Number = ((x + 2) > 0) ? (x + 2) : 0
var p1:Number = ((x + 1) > 0) ? (x + 1) : 0
var p2:Number = (x > 0) ? x : 0
var p3:Number = ((x - 1) > 0) ? (x - 1) : 0

return (1 / 6) * (p0 * p0 * p0 - 4 * (p1 * p1 * p1) + 6 * (p2 * p2 * p2) -
4 * (p3 * p3 * p3));
}

/**
Computes the value of a pixel that is not on a pixel boundary.

@param x The sub-pixel precision x-coordinate.
@param y The sub-pixel precision y-coordinate.
*/
private static function getPixelBicubic(bmd:BitmapData, x:Number, y:Number):Number
{
var i:int = (int)(x);
var j:int = (int)(y);

if (((i - 1) < 0) || ((j - 1) = bmd.width) || ((i + 2) >= bmd.width) ||
((j + 1) >= bmd.height) || ((j + 2) >= bmd.height))
return bmd.getPixel(i, j);

var dx:Number = x - i;
var dy:Number = y - j;
var rsum:Number = 0;
var gsum:Number = 0;
var bsum:Number = 0;

var Rmdx:Array = new Array(4);
var Rdyn:Array = new Array(4);
for (var m:int = -1; m <= 2; ++m)
Rmdx[m + 1] = A(m - dx);
for (var n:int = -1; n <= 2; ++n)
Rdyn[n + 1] = A(dy - n);

for (m = -1; m <= 2; ++m)
{
for (n = -1; n > 16) & 0×0FF;
var g:int = (rgb >> & 0×0FF;
var b:int = (rgb >> 0) & 0×0FF;

var Rres:Number = Rmdx[m + 1] * Rdyn[n + 1];
rsum += r * Rres;
gsum += g * Rres;
bsum += b * Rres;
}
}

var red:int = (int)(rsum + 0.5);
if (red 255)
red = 255;
var green:int = (int)(gsum + 0.5);
if (green 255)
green = 255;
var blue:int = (int)(bsum + 0.5);
if (blue 255)
blue = 255;

return (red << 16) | (green << | (blue << 0);
}

I worked around the issue and found an interesting solution. It seams, if you apply a blur on the original image and then resize, the quality of the resized image will be much nicer. Check out my post here http://kun-janos.ro/blog/?p=107