imageeffects.java

j2me源代码

                indexImageEffect = 1;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else if (c == cmdNegative) {
                indexImageEffect = 2;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else if (c == cmdEmboss) {
                indexImageEffect = 3;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else if (c == cmdSepia) {
                indexImageEffect = 4;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else if (c == cmdSolarize) {
                indexImageEffect = 5;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else if (c == cmdRedEye) {
                indexImageEffect = 6;
                effectSelector.setSelectedIndex(indexImageEffect, true);
                output_changed = true;
            } else {
            }

            if (input_changed) {
                changeOriginalImageItem();
            };
            if (input_changed || output_changed) {
                //run test
                createProcessedImage();

                if (!need_callback) {
                    // replace old image (if any) with new one
                    changeProcessedImageItem();
                }
            }
        }
    }
    
    //to implement MediaProcessorListener
    public void mediaProcessorUpdate(MediaProcessor processor,
                                     String event,
                                     Object eventData) {
        if (need_callback) {
            if (event == MediaProcessorListener.PROCESSING_COMPLETED) {
                final int[] processed_size = getProcessedImageSize();
                processedImage = createStreamARGBImage(
                    outputStream, need_output_stream, 
                    processed_size[0],
                    processed_size[1]);
                changeProcessedImageItem();
            }
            else if (event == MediaProcessorListener.PROCESSING_ABORTED ||
                     event == MediaProcessorListener.PROCESSING_ERROR ||
                     event == MediaProcessorListener.PROCESSING_STOPPED) {
                processedImage = createTestImage();
                changeProcessedImageItem();
            } else if (event == MediaProcessorListener.PROCESSING_STARTED) {
            } else if (event == MediaProcessorListener.PROCESSOR_REALIZED) {
            }
        }
        //print to console
        System.out.println(event);
    }

    private void changeOriginalImageItem() {
        // negative to show that there is no processed images to show
        processedImageItemIndex = -1;

        // prepare source image 
        inputStream = getClass().getResourceAsStream(stream_array[indexInputImageFormat]);
        try {
            sourceImage = Image.createImage(inputStream);
        } catch (java.io.IOException e) {
            System.out.println("IOException: " + 
                "Unable to get resource! Generating test image!");
            sourceImage = createTestImage();
        };
        
        resultViewer.deleteAll();
        resultViewer.append(new ImageItem("Original Image:\n"+
            "format=" + format_array[indexInputImageFormat], 
            sourceImage,   //the image to append
            ImageItem.LAYOUT_CENTER |
            ImageItem.LAYOUT_NEWLINE_BEFORE | ImageItem.LAYOUT_NEWLINE_AFTER, 
            null));
    }
    
    private int[] getProcessedImageSize() {
        int size[] = new int[2];
        size[0] = sourceImage.getWidth() * scale_array[indexOutputScaleW] / 100;
        size[1] = sourceImage.getHeight() * scale_array[indexOutputScaleH] / 100;
        //swap width & height in case of rotation to 90 & 270 degrees
        if ((indexOutputRotate & 0x01) != 0) {
            final int temp = size[0];
            size[0] = size[1];
            size[1] = temp;
        };
        return size; //[0] contains width & [1] contains height
    }
            
    private void changeProcessedImageItem() {
        //remove previous processed image 
        if (processedImageItemIndex >= 0) {
            resultViewer.delete(processedImageItemIndex);
            processedImageItemIndex = -1;
        }
        
        //display result
        processedImageItemIndex = 
            resultViewer.append(new ImageItem("Processed Image:\n" + 
            "format=" + format_array[indexOutputImageFormat] + " " +
            "effect=" + effect_array[indexImageEffect], 
            processedImage,   //the image to append
            ImageItem.LAYOUT_CENTER |
            ImageItem.LAYOUT_NEWLINE_BEFORE | ImageItem.LAYOUT_NEWLINE_AFTER, 
            null));
    }
    
    private void createProcessedImage() {

        try {

            MediaProcessor mp = GlobalManager.createMediaProcessor(
                    "image/" + format_array[indexInputImageFormat]);

            mp.addMediaProcessorListener(this);

            // create a OutputStream that will receive the resulting image
            outputStream = new ByteArrayOutputStream();

            if (need_input_stream) {
                //need to create stream again or rewind it ...
                inputStream = getClass().getResourceAsStream(stream_array[indexInputImageFormat]);
                mp.setInput(inputStream, MediaProcessor.UNKNOWN);
            } else {
                mp.setInput(sourceImage);
            }
            mp.setOutput(outputStream);
 
            // Define effects to be applied during processing
            ImageTransformControl itc = (ImageTransformControl)mp.getControl(
                "javax.microedition.amms.control.imageeffect.ImageTransformControl");
            ImageEffectControl iec = (ImageEffectControl)mp.getControl(
                "javax.microedition.amms.control.imageeffect.ImageEffectControl");
            OverlayControl ioc = (OverlayControl)mp.getControl(
                "javax.microedition.amms.control.imageeffect.OverlayControl");
            ImageFormatControl ifc = (ImageFormatControl)mp.getControl(
                "javax.microedition.amms.control.ImageFormatControl");
            EffectOrderControl eoc = (EffectOrderControl)mp.getControl(
                "javax.microedition.amms.control.EffectOrderControl");
            
            //ImageTransformControl settings
            {
                // if user requested border, then source image to transform will be increased, 
                // and thus processed image will have black rectangle around it
                final int border = indexOutputBorder[0] ? 10 : 0;
                itc.setSourceRect(
                    -border, -border, 
                    itc.getSourceWidth() + 2 * border, 
                    itc.getSourceHeight() + 2 * border);
                itc.setTargetSize(
                    itc.getSourceWidth() * scale_array[indexOutputScaleW] / 100,
                    itc.getSourceHeight() * scale_array[indexOutputScaleH] / 100, 
                    indexOutputRotate * 90);
                itc.setEnabled(true);
            }
                
            //ImageEffectControl settings
            if (indexImageEffect != 0) {
                iec.setPreset(effect_array[indexImageEffect]);
                iec.setEnabled(true);
            }
            else {
                iec.setEnabled(false);
            }
                
            //OverlayControl settings
            {
                final int processed_size[] = getProcessedImageSize();
                boolean ioc_enable = false;
                ioc.clear();
                for (int j = 0; j < 2; ++j) { 
                    if (indexOutputOverlay[j]) {
                        int color = 
                                (argb_color[j][0] << 24) | 
                                (argb_color[j][1] << 16) | 
                                (argb_color[j][2] <<  8) | 
                                (argb_color[j][3] <<  0); 
                        ioc_enable = true;
                        for (int i = 0; i < argb_buffer.length; ++i) {
                            argb_buffer[i] = color;
                        }
                        Image overlay_image = Image.createRGBImage(
                                argb_buffer, 
                                overlay_size[j], 
                                overlay_size[1-j], 
                                true);
                        int order = 
                        ioc.insertImage(overlay_image, 
                                (processed_size[0] - overlay_size[j]) / 2, 
                                (processed_size[1] - overlay_size[1-j]) / 2, 
                                j);
                    }
                }
                ioc.setEnabled(ioc_enable);
            }
            
            //ImageFormatControl settings
            ifc.setFormat("image/" + format_array[indexOutputImageFormat]);
            
            //EffectOrderControl settings
            {
                indexEffectOrder[0] = eoc.setEffectOrder(itc, indexEffectOrder[0]);
                indexEffectOrder[1] = eoc.setEffectOrder(iec, indexEffectOrder[1]);
                indexEffectOrder[2] = eoc.setEffectOrder(ioc, indexEffectOrder[2]);
                effectOrder[0].setString(Integer.toString(indexEffectOrder[0]));
                effectOrder[1].setString(Integer.toString(indexEffectOrder[1]));
                effectOrder[2].setString(Integer.toString(indexEffectOrder[2]));
            };

 
            // Do the actual processing. If you do not want to use a blocking call, 
            // use start() and MediaProcessorListener.
            if (need_callback) {
                mp.start();
            } else {
                mp.complete();

                final int[] processed_size = getProcessedImageSize();
                processedImage = createStreamARGBImage(
                    outputStream, need_output_stream, 
                    processed_size[0],
                    processed_size[1]);
            }

        } catch (MediaException me) {
            me.printStackTrace();
            System.out.println("MediaException: " + 
                "Unable to create processed image !");
            processedImage = createTestImage();
        }

    }

    private static Image createTestImage() {

        Image image  = Image.createImage(72, 72);

        Graphics g = image.getGraphics();

        g.setColor(0xff0000);
        g.fillRect(0, 0, 
                   image.getWidth(), image.getHeight()/3);

        g.setColor(0x00ff00);
        g.fillRect(0, image.getHeight()/3, 
                   image.getWidth(), image.getHeight()/3);

        g.setColor(0x0000ff);
        g.fillRect(0, (image.getHeight()*2)/3, 
                   image.getWidth(), image.getHeight()/3);

        return image;
    }

    private static Image createStreamARGBImage(
            ByteArrayOutputStream os, boolean from_stream, int w, int h) {
        byte[] bytearray = os.toByteArray();
        
        if (from_stream) {
            //return Image.createImage(bytearray, 0, bytearray.length);
            try {
            return Image.createImage(
                    new ByteArrayInputStream(bytearray, 0, bytearray.length));
            } catch (java.io.IOException e) {
                System.out.println("IOException: " + 
                    "Unable to get input stream! Generating test image!");
                return createTestImage();
            }
        } else {
            return Image.createRGBImage(
                byteArrayToIntArray(bytearray), w, h, true);
        }
    }

    private static int[] byteArrayToIntArray(byte[] bytes) {
        int[] ints = new int[bytes.length / 4];

        int intcount, bytecount;
        for (intcount = 0, bytecount = 0; bytecount < bytes.length; ) {
            ints[intcount] = 
                (( ((int)(bytes[bytecount + 0])) << 24) & 0xFF000000) |  //A
                (( ((int)(bytes[bytecount + 1])) << 16) & 0x00FF0000) |  //R
                (( ((int)(bytes[bytecount + 2])) << 8)  & 0x0000FF00) |  //G
                (( ((int)(bytes[bytecount + 3]))        & 0x000000FF) ); //B

            intcount++;
            bytecount+=4;

        }
        return ints;
    }
}