如果从字节数组转换为位图对象，则返回null值。 为什么？

Question

I'm trying to develop an application in Android and I'm having a problem I can't figure out how to solve.

Description:

The application consists of image processing and one of the routines is as follows. An image file (PNG) is converted into a array of bytes databyteimage[] with n elements, a part of this array ex: from databyteimage[i] to databyteimage[i+k] consecutive with k elements and " i " is offset databyteimage[], the LSB (Least Significant Bit) is replaced, the value what is replaced coms from other array of bytes ex:datareplace[] with m elements the value of k is m*8. This operation is done using operations on bits . After this process, a new string databyteimage[] is created.

The problem:

When trying to create the BITMAP object from the new array databyteimage[] returns NULL to displaty or show the new image.

I would appreciate if you could help me find a solution to this problem, since until now no one could help me.

***// GetByte method from Image***

private byte[] getByteImageData(String filePath) {
        /*
        Bitmap bitmap = BitmapFactory.decodeFile(filePath);
        Bitmap mutable = bitmap.copy(Bitmap.Config.RGB_565, true);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        mutable.compress(Bitmap.CompressFormat.PNG, 100, baos);

    return baos.toByteArray();
        */


        byte[] _imagebytedata = new byte[1024];
        InputStream _input = null;

        try {
            if (filePath != null && (filePath.length() > 0)) {

                // Create a file for image
                File _fileimage = new File(filePath);

                if (_fileimage.exists()) {

                    // Get the byte from file image
                    _input = new BufferedInputStream(new FileInputStream(
                            _fileimage));
                    _imagebytedata = new byte[(int) _fileimage.length()];
                    _input.read(_imagebytedata, 0, (int) _fileimage.length());
                    _input.close();
                }
            }
        } catch (Exception e) {

        }

**// Bitwise operations to change LSB of byte array image**

private byte[] Text(byte[] imagedata, byte[] textmess, int offset) {


        for (int i = 0; i < textmess.length; ++i) {
            int add = textmess[i];

            for (int bit = 7; bit >= 0; --bit, ++offset) {
                int b = (add >>> bit) & 1;
                imagedata[offset] = (byte) ((imagedata[offset] & 0xFE) |b);
            }
        }
        return imagedata;
    }

***//Save image from new byte array***

private boolean saveImage(String pathFile,byte[] encodedimage) {

        OutputStream _output = null;
        File _newFileImage = new File(pathFile);
        byte[] _encodedimage = encodedimage;
        //Bitmap _imagebitmap = BitmapFactory.decodeByteArray(encodedimage, 0, encodedimage.length);

        if (_newFileImage.exists()) {
            try {

                _output = new BufferedOutputStream(new FileOutputStream(
                        _newFileImage));
                _output.write(_encodedimage, 0, _encodedimage.length);
                _output.flush();
                _output.close();
                return true;

            } catch (Exception e) {
            }
            ;

        }// _newFileImage.exists()
        return false;
    }


public  boolean encodeTextInFile(String filepath, String text) {

        byte[] _newimagebytedata;
        byte[] _imagebytedata = getByteImageData(filepath);
        byte[] _textbytedata = text.getBytes();
        byte[] _lengthbytedata = byteConversion(text.length());


        _newimagebytedata = Text(_imagebytedata, _lengthbytedata, 33);   
        _newimagebytedata = Text(_imagebytedata, _textbytedata, 65);  

   **// The value of variable _bitmapdoi is null here is the problem**

 Bitmap _bitmapdoi = BitmapFactory.decodeByteArray(_newimagebytedata, 0,_newimagebytedata.length);
        return saveImage(filepath, _newimagebytedata);
    }

Answer 1

What you are reading in getByteImageData is not a bitmap. It is a file, most likely a compressed image. Working on the bytes from this file is very different from working on the image pixels. I suggest you work on the actual Bitmap object:

Load the bitmap:

Bitmap bitmap = BitmapFactory.decodeFile(filePath);
// Not quite sure if the returned bitmap is mutable, so
Bitmap mutable = bitmap.copy(Bitmap.Config.RGB_565, true);

Modify a pixel:

int pixelRGB = mutable.getPixel(x, y);
// Do whatever you have to do
mutable.setPixel(x, y, pixelRGB);

Write it back:

mutable.compress(Bitmap.CompressFormat.PNG, 100, new ByteArrayOutputStream(new FileOutputStream(_newFileImage)));