Smooth filter..

Question

Hi,
I've built a simple smooth filter Codec.. but I get strange colors near object edges.. can it be somekind of color bleeding? or there is a bug in my code?
Perhaps in the coversion from and to byte?
here is the code thanks
package camgrabtests;
import javax.media.format.*;
import java.awt.*;
import java.awt.event.*;
import javax.media.*;
import java.util.*;
//controllo dall'alto
public class ResizeBlurEffect implements Effect,ControllerListener {
private Format[] inputFormats;
private Format[] outputFormats;
private Format inputFormat;
private Dimension size;
private Format outputFormat;
protected int width;
protected int height;
protected int center_x;
protected int center_y;
private int xBlurFactor;
private int yBlurFactor;
Format matches(Format in, Format outs[]) {
for (int i = 0; i < outs.length; i++) {
if (in.matches(outs))
return outs[i];
return null;
ResizeBlurEffect(
int width,
int height,
int xBlurFactor,
int yBlurFactor
this.width=width;
this.height=height;
this.xBlurFactor=xBlurFactor;
this.yBlurFactor=yBlurFactor;
//target di default
inputFormats = new Format[] {
new RGBFormat(null,
Format.NOT_SPECIFIED,
Format.byteArray,
Format.NOT_SPECIFIED,
24,
3, 2, 1,
3, Format.NOT_SPECIFIED,
Format.TRUE,
Format.NOT_SPECIFIED)
outputFormats = new Format[] {
new RGBFormat(new Dimension(width,height),
width*height*3,
Format.byteArray,
Format.NOT_SPECIFIED,
24,
3, 2, 1,
3, Format.NOT_SPECIFIED,
Format.TRUE,
Format.NOT_SPECIFIED)
// methods for interface Codec
public Format[] getSupportedInputFormats() {
return inputFormats;
public Format [] getSupportedOutputFormats(Format input) {
if (input == null) {
return outputFormats;
if (matches(input, inputFormats) != null) {
return new Format[] { outputFormats[0].intersects(input) };
} else {
return new Format[0];
public Format setInputFormat(Format input) {
inputFormat = input;
return input;
public Format setOutputFormat(Format output) {
if (output == null || matches(output, outputFormats) == null)
return null;
RGBFormat incoming = (RGBFormat) output;
size = incoming.getSize();
size.height=height;
size.width=width;
//int maxDataLength = incoming.getMaxDataLength();
int lineStride = incoming.getLineStride();
float frameRate = incoming.getFrameRate();
int flipped = incoming.getFlipped();
int endian = incoming.getEndian();
int pixelstride=incoming.getPixelStride();
if (size == null)
return null;
int maxDataLength = height * width * 3;
lineStride = width * 3;
outputFormat = outputFormats[0].intersects(new RGBFormat(size,
maxDataLength,
incoming.getDataType(),
frameRate,
Format.NOT_SPECIFIED,
Format.NOT_SPECIFIED,
Format.NOT_SPECIFIED,
Format.NOT_SPECIFIED,
pixelstride,
lineStride,
flipped,
endian));
System.out.println("final outputformat = " + outputFormat);
return outputFormat;
//funzione dove avvine il processamento dello stream
public int process(Buffer inBuffer, Buffer outBuffer) {
long max_area = 1;
int maxInputIndex=0;
int maxoutputIndex=0;
System.out.println("process in:" +inBuffer.getFormat());
int outputDataLength = ((VideoFormat)outputFormat).getMaxDataLength();
validateByteArraySize(outBuffer, outputDataLength);
System.out.println("process out:" +outBuffer.getFormat());
outBuffer.setLength(outputDataLength);
outBuffer.setFormat(outputFormat);
outBuffer.setFlags(inBuffer.getFlags());
byte [] inData = (byte[]) inBuffer.getData();
byte [] outData = (byte[]) outBuffer.getData();
RGBFormat vfIn = (RGBFormat) inBuffer.getFormat();
Dimension sizeIn = vfIn.getSize();
final int pixStrideIn = vfIn.getPixelStride();
final int lineStrideIn = vfIn.getLineStride();
int iw = sizeIn.width;
int ih = sizeIn.height;
final int filter_width=Math.max(iw/width,1)+xBlurFactor;
final int filterHeight=Math.max(ih/height,1)+yBlurFactor;
byte maxInputRed=+127;
long maxOutputRed=+127000;
for (int y = 0,counter=0; y < height; y++)
for (int x = 0; x < width; x++,counter+=3) {
final int start_Y,start_X,end_X,end_Y;
start_Y= Math.min(Math.max(y-filterHeight/2,0),ih);
//System.out.println("start_Y: "+start_Y);
end_Y=Math.min(Math.max(y+Math.max(filterHeight/2,1),0),ih);
start_X= Math.min(Math.max(x-filter_width/2,0),iw);
//System.out.println("start_X: "+start_X);
end_X=Math.min(Math.max(x+Math.max(filter_width/2,1),0),iw);
//System.out.println("end_X: "+end_X);
if ( outData.length < filter_width*filterHeight*pixStrideIn ) {
System.out.println("the buffer is not full");
return BUFFER_PROCESSED_FAILED;
// System.out.println("count = " + count);
// System.out.println("vsin = " + vsin + " vcos = " + vcos);
int index=startY*lineStrideIn+start_X*pixStrideIn;
int outidx=0;
final int actual_lenght=(end_X-start_X);
final int step=(endX-start_X)*pixStrideIn;
final int destLineStride= width*pixStrideIn;
//System.out.println("step: "+_step);
//System.out.println("_index start: "+_index);
float acc1=0,acc2=0,acc3=0;
for (int i = start_Y; i < end_Y; i++) {
for (int j = 0; j < _step; j+=3) {
if(x==width/2&&y==height/2)
System.out.println("partial red= "+inData[_index+j]);
acc1+=inData[_index+j];
acc2+=inData[_index+j+1];
acc3+=inData[_index+j+2];
_index+=lineStrideIn;
float area=actual_lenght*(end_Y-start_Y);
outData[counter]=(byte)(acc1/area);
if(x==width/2&&y==height/2)
System.out.println("mean red= "+outData[counter]);
outData[counter+1]=(byte)(acc2/area);
outData[counter+2]=(byte)(acc3/area);
return BUFFER_PROCESSED_OK;
public String getName() {
return "Rotation Effect";
public void open() {
public void close() {
public void reset() {
// methods for interface javax.media.Controls
public Object getControl(String controlType) {
return null;
public Object[] getControls() {
return null;
byte[] validateByteArraySize(Buffer buffer,int newSize) {
Object objectArray=buffer.getData();
byte[] typedArray;
if (objectArray instanceof byte[]) {     // is correct type AND not null
typedArray=(byte[])objectArray;
if (typedArray.length >= newSize ) { // is sufficient capacity
return typedArray;
byte[] tempArray=new byte[newSize]; // re-alloc array
System.arraycopy(typedArray,0,tempArray,0,typedArray.length);
typedArray = tempArray;
} else {
typedArray = new byte[newSize];
buffer.setData(typedArray);
return typedArray;
//implements controllerListener
public void controllerUpdate(ControllerEvent ce) {
System.out.println(ce);
// if (ce instanceof EndOfMediaEvent) {
// //System.out.println("Dimensione vettore dati: "+vettoreDati.size());
// //SalvaDati sd=new SalvaDati(nomeFile+".blob",vettoreDati);
// if (ce instanceof FormatChangeEvent) {
// System.out.println("Dimensione vettore dati: "+vettoreDati.size());
// SalvaDati sd=new SalvaDati(nomeFile+".blob",vettoreDati);
public int getWidth() {
return width;
public void setWidth(int width) {
this.width = width;
public void setRescaleBlurFactors(
int width,
int height,
int xBlurFactor,
int yBlurFactor
this.width=width;
this.height=height;
this.xBlurFactor=xBlurFactor;
this.yBlurFactor=yBlurFactor;
public static void main(String args[]){
int a=0;
byte b=-20;
for (int i = 0; i < 100; i++) {
a+=b;
System.out.println("a: "+a);
public int getXBlurFactor() {
return xBlurFactor;
public void setXBlurFactor(int xBlurFactor) {
this.xBlurFactor = xBlurFactor;
public int getYBlurFactor() {
return yBlurFactor;
public void setYBlurFactor(int yBlurFactor) {
this.yBlurFactor = yBlurFactor;

Answer 1

there was a problem in the conversion from byte to int
for this rgb format
i added this 2 functions and now it works..
private final byte convert(float x){
return (byte)x;//((x>127)?(x-255):x);
//return (byte)x;
private final int deconvert(byte x){
return (int)(x & 0xff);
//return x;
and changed the code in this way
//inside teh process method
for (int i = start_Y; i < end_Y; i++) {
for (int j = 0; j < _step; j+=3) {
//if(x==width/2&&y==height/2)
// System.out.println("partial red= "+inData[_index+j]);
acc1+=deconvert(inData[_index+j]);
acc2+=deconvert(inData[_index+j+1]);
acc3+=deconvert(inData[_index+j+2]);}
_index+=lineStrideIn;
float area=actual_lenght*(end_Y-start_Y);
outData[counter]=convert(acc1/area);
//if(x==width/2&&y==height/2)
// System.out.println("new mean red= "+outData[counter]);
outData[counter+1]=convert(acc2/area);
outData[counter+2]=convert(acc3/area);
Message was edited by:
dimitri