Android：将位图保存为 bmp 文件格式

Question

我在内存中有一个位图，我需要将它保存在一个 bmp 文件中（使用 bmp file format）。

有没有办法在 Android 上做到这一点？

（我阅读了很多建议使用 png 格式的帖子 - 这是无损格式 - 但这不是我需要的：我真的需要 bmp 格式）。

我已经有一些代码可以使用Bitmap.compress 方法将其保存为 jpeg 或 png：

/**
 * Save data to file using format.
 * When format is null : the bitmap will be saved in bmp format
 **/

public void writeBitmapToFile(Bitmap data, File file, Bitmap.CompressFormat format) {
    FileOutputStream os = null;
    try {
        os = new FileOutputStream(file);
        if(format==null){

            //TODO : write data to file using the bmp format

        }else{
            data.compress(format, 100, os); //ok for JPEG and PNG
        }
        os.flush();
    } catch (Exception e) {
        //irrelevant code
    } finally {
        //irrelevant code
    }
}

Answer 1

（我正在回答我自己的问题）

这是我目前的解决方案。它来源于此来源：https://github.com/ultrakain/AndroidBitmapUtil（感谢 ultrakain 和 @Francescoverheye）

我只是修复了计算必须添加到每行的虚拟字节的一个小错误（因此每行的字节长度是 4 的倍数（根据 bmp 格式规范的要求）。

我还做了一些改变来提高性能。

import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;

import android.graphics.Bitmap;
import android.util.Log;

public class AndroidBmpUtil {

    private static final int BMP_WIDTH_OF_TIMES = 4;
    private static final int BYTE_PER_PIXEL = 3;

    /**
     * Android Bitmap Object to Window's v3 24bit Bmp Format File
     * @param orgBitmap
     * @param filePath
     * @return file saved result
     */
    public static boolean save(Bitmap orgBitmap, String filePath) throws IOException {
        long start = System.currentTimeMillis();
        if(orgBitmap == null){
            return false;
        }

        if(filePath == null){
            return false;
        }

        boolean isSaveSuccess = true;

        //image size
        int width = orgBitmap.getWidth();
        int height = orgBitmap.getHeight();

        //image dummy data size
        //reason : the amount of bytes per image row must be a multiple of 4 (requirements of bmp format)
        byte[] dummyBytesPerRow = null;
        boolean hasDummy = false;
        int rowWidthInBytes = BYTE_PER_PIXEL * width; //source image width * number of bytes to encode one pixel.
        if(rowWidthInBytes%BMP_WIDTH_OF_TIMES>0){
            hasDummy=true;
            //the number of dummy bytes we need to add on each row
            dummyBytesPerRow = new byte[(BMP_WIDTH_OF_TIMES-(rowWidthInBytes%BMP_WIDTH_OF_TIMES))];
            //just fill an array with the dummy bytes we need to append at the end of each row
            for(int i = 0; i < dummyBytesPerRow.length; i++){
                dummyBytesPerRow[i] = (byte)0xFF;
            }
        }

        //an array to receive the pixels from the source image
        int[] pixels = new int[width * height];

        //the number of bytes used in the file to store raw image data (excluding file headers)
        int imageSize = (rowWidthInBytes+(hasDummy?dummyBytesPerRow.length:0)) * height;
        //file headers size
        int imageDataOffset = 0x36; 

        //final size of the file
        int fileSize = imageSize + imageDataOffset;

        //Android Bitmap Image Data
        orgBitmap.getPixels(pixels, 0, width, 0, 0, width, height);

        //ByteArrayOutputStream baos = new ByteArrayOutputStream(fileSize);
        ByteBuffer buffer = ByteBuffer.allocate(fileSize);

        /**
         * BITMAP FILE HEADER Write Start
         **/
        buffer.put((byte)0x42);
        buffer.put((byte)0x4D);

        //size
        buffer.put(writeInt(fileSize));

        //reserved
        buffer.put(writeShort((short)0));
        buffer.put(writeShort((short)0));

        //image data start offset
        buffer.put(writeInt(imageDataOffset));

        /** BITMAP FILE HEADER Write End */

        //*******************************************

        /** BITMAP INFO HEADER Write Start */
        //size
        buffer.put(writeInt(0x28));

        //width, height
        //if we add 3 dummy bytes per row : it means we add a pixel (and the image width is modified.
        buffer.put(writeInt(width+(hasDummy?(dummyBytesPerRow.length==3?1:0):0)));
        buffer.put(writeInt(height));

        //planes
        buffer.put(writeShort((short)1));

        //bit count
        buffer.put(writeShort((short)24));

        //bit compression
        buffer.put(writeInt(0));

        //image data size
        buffer.put(writeInt(imageSize));

        //horizontal resolution in pixels per meter
        buffer.put(writeInt(0));

        //vertical resolution in pixels per meter (unreliable)
        buffer.put(writeInt(0));

        buffer.put(writeInt(0));

        buffer.put(writeInt(0));

        /** BITMAP INFO HEADER Write End */

        int row = height;
        int col = width;
        int startPosition = (row - 1) * col;
        int endPosition = row * col;
        while( row > 0 ){
            for(int i = startPosition; i < endPosition; i++ ){
                buffer.put((byte)(pixels[i] & 0x000000FF));
                buffer.put((byte)((pixels[i] & 0x0000FF00) >> 8));
                buffer.put((byte)((pixels[i] & 0x00FF0000) >> 16));
            }
            if(hasDummy){
                buffer.put(dummyBytesPerRow);
            }
            row--;
            endPosition = startPosition;
            startPosition = startPosition - col;
        }

        FileOutputStream fos = new FileOutputStream(filePath);
        fos.write(buffer.array());
        fos.close();
        Log.v("AndroidBmpUtil" ,System.currentTimeMillis()-start+" ms");

        return isSaveSuccess;
    }

    /**
     * Write integer to little-endian
     * @param value
     * @return
     * @throws IOException
     */
    private static byte[] writeInt(int value) throws IOException {
        byte[] b = new byte[4];

        b[0] = (byte)(value & 0x000000FF);
        b[1] = (byte)((value & 0x0000FF00) >> 8);
        b[2] = (byte)((value & 0x00FF0000) >> 16);
        b[3] = (byte)((value & 0xFF000000) >> 24);

        return b;
    }

    /**
     * Write short to little-endian byte array
     * @param value
     * @return
     * @throws IOException
     */
    private static byte[] writeShort(short value) throws IOException {
        byte[] b = new byte[2];

        b[0] = (byte)(value & 0x00FF);
        b[1] = (byte)((value & 0xFF00) >> 8);

        return b;
    }
}

Answer 2

将 android Bitmap 对象转换为 8bit bmp 文件的代码。 它源自这个 C# 项目：https://www.codeproject.com/articles/70442/c-rgb-to-palette-based-bit-greyscale-bitmap-clas

import android.graphics.Bitmap;
import android.graphics.Color;


public class BitmapConvertor {

    private  byte[] Color_palette = new byte[1024]; //a palette containing 256 colors
   private   byte[] BMP_File_Header = new byte[14];
   private  byte[] DIB_header = new byte[40];
  private   byte[] Bitmap_Data = null;


    //returns a byte array of a grey scale bitmap image
    public    byte[] CreateGrayBitmapArray(Bitmap Image) {
        try {
            create_parts(Image);
            //Create the array
            byte[] bitmap_array = new byte[BMP_File_Header.length + DIB_header.length
                    + Color_palette.length + Bitmap_Data.length];
            Copy_to_Index(bitmap_array, BMP_File_Header, 0);
            Copy_to_Index(bitmap_array, DIB_header, BMP_File_Header.length);
            Copy_to_Index(bitmap_array, Color_palette, BMP_File_Header.length + DIB_header.length);
            Copy_to_Index(bitmap_array, Bitmap_Data, BMP_File_Header.length + DIB_header.length + Color_palette.length);

            return bitmap_array;
        } catch (Exception e) {
            return null; //return a null single byte array if fails
        }
    }


    //creates byte array of 256 color grayscale palette
    private   byte[] create_palette() {
        byte[] color_palette = new byte[1024];
        for (int i = 0; i < 256; i++) {
            color_palette[i * 4 + 0] = (byte) (i); //bule
            color_palette[i * 4 + 1] = (byte) (i); //green
            color_palette[i * 4 + 2] = (byte) (i); //red
            color_palette[i * 4 + 3] = (byte) 0; //padding
        }
        return color_palette;
    }


    //adds dtata of Source array to Destinition array at the Index
   private   boolean Copy_to_Index(byte[] destination, byte[] source, int index) {
        try {
            for (int i = 0; i < source.length; i++) {
                destination[i + index] = source[i];
            }
            return true;
        } catch (Exception e) {
            return false;
        }
    }


    //create different part of a bitmap file
  private    void create_parts(Bitmap img) {
        //Create Bitmap Data
        Bitmap_Data = ConvertToGrayscale(img);
        //Create Bitmap File Header (populate BMP_File_Header array)
        Copy_to_Index(BMP_File_Header, new byte[]{(byte) 'B', (byte) 'M'}, 0); //magic number
        Copy_to_Index(BMP_File_Header, writeInt(BMP_File_Header.length
                + DIB_header.length + Color_palette.length + Bitmap_Data.length), 2); //file size
        Copy_to_Index(BMP_File_Header, new byte[]{(byte) 'M', (byte) 'C', (byte) 'A', (byte) 'T'}, 6); //reserved for application generating the bitmap file (not imprtant)
        Copy_to_Index(BMP_File_Header, writeInt(BMP_File_Header.length
                + DIB_header.length + Color_palette.length), 10); //bitmap raw data offset
        //Create DIB Header (populate DIB_header array)
        Copy_to_Index(DIB_header, writeInt(DIB_header.length), 0); //DIB header length
        Copy_to_Index(DIB_header, writeInt(((Bitmap) img).getWidth()), 4); //image width
        Copy_to_Index(DIB_header, writeInt(((Bitmap) img).getHeight()), 8); //image height
        Copy_to_Index(DIB_header, new byte[]{(byte) 1, (byte) 0}, 12); //color planes. N.B. Must be set to 1
        Copy_to_Index(DIB_header, new byte[]{(byte) 8, (byte) 0}, 14); //bits per pixel
        Copy_to_Index(DIB_header, writeInt(0), 16); //compression method N.B. BI_RGB = 0
        Copy_to_Index(DIB_header, writeInt(Bitmap_Data.length), 20); //lenght of raw bitmap data
        Copy_to_Index(DIB_header, writeInt(1000), 24); //horizontal reselution N.B. not important
        Copy_to_Index(DIB_header, writeInt(1000), 28); //vertical reselution N.B. not important
        Copy_to_Index(DIB_header, writeInt(256), 32); //number of colors in the palette
        Copy_to_Index(DIB_header, writeInt(0), 36); //number of important colors used N.B. 0 = all colors are imprtant
        //Create Color palett
        Color_palette = create_palette();
    }


    //convert the color pixels of Source image into a grayscale bitmap (raw data)
  private    byte[] ConvertToGrayscale(Bitmap Source) {
        Bitmap source = (Bitmap) Source;
        int padding = (source.getWidth() % 4) != 0 ? 4 - (source.getWidth() % 4) : 0; //determine padding needed for bitmap file
        byte[] bytes = new byte[source.getWidth() * source.getHeight() + padding * source.getHeight()]; //create array to contain bitmap data with paddin
        for (int y = 0; y < source.getHeight(); y++) {
            for (int x = 0; x < source.getWidth(); x++) {
                int pixel = source.getPixel(x, y);
                int g = (int) (0.3 * Color.red(pixel) + 0.59 * Color.green(pixel) + 0.11 * Color.blue(pixel)); //grayscale shade corresponding to rgb
                bytes[(source.getHeight() - 1 - y) * source.getWidth() + (source.getHeight() - 1 - y) * padding + x] = (byte) g;
            }
            //add the padding
            for (int i = 0; i < padding; i++) {
                bytes[(source.getHeight() - y) * source.getWidth() + (source.getHeight() - 1 - y) * padding + i] = (byte) 0;
            }
        }
        return bytes;
    }


    /**
     * Write integer to little-endian
     *
     * @param value
     * @return
     * @throws IOException
     */
    private  byte[] writeInt(int value) {
        byte[] b = new byte[4];

        b[0] = (byte) (value & 0x000000FF);
        b[1] = (byte) ((value & 0x0000FF00) >> 8);
        b[2] = (byte) ((value & 0x00FF0000) >> 16);
        b[3] = (byte) ((value & 0xFF000000) >> 24);

        return b;
    }
}

Answer 3

不幸的是，就我而言，上面的答案并不完全适用于灰度图像。不知道为什么。

这就是我写这个的原因（另外我使用ByteBuffer，因为性能）：

import android.graphics.Bitmap;
import android.util.Log;

import java.io.FileOutputStream;
import java.io.OutputStream;
import java.nio.ByteBuffer;

public class BmpFile {
    // Private constants
    private final static int BITMAPFILEHEADER_SIZE = 14;
    private final static int BITMAPINFOHEADER_SIZE = 40;
    // Private variable declaration
    // Bitmap file header
    private byte bitmapFileHeader[] = new byte[14];
    private byte bfType[] = {'B', 'M'};
    private int bfSize = 0;
    private int bfReserved1 = 0;
    private int bfReserved2 = 0;
    private int bfOffBits = BITMAPFILEHEADER_SIZE + BITMAPINFOHEADER_SIZE;
    // Bitmap info header
    private byte bitmapInfoHeader[] = new byte[40];
    private int biSize = BITMAPINFOHEADER_SIZE;
    private int biWidth = 0;
    private int biHeight = 0;
    private int biPlanes = 1;
    private int biBitCount = 24;
    private int biCompression = 0;
    private int biSizeImage = 0x030000;
    private int biXPelsPerMeter = 0x0;
    private int biYPelsPerMeter = 0x0;
    private int biClrUsed = 0;
    private int biClrImportant = 0;
    // Bitmap raw data
    private int pixels[];
    // File section
    private ByteBuffer buffer = null;
    private OutputStream outputStream;

    // Default constructor
    public BmpFile() {
    }

    public void saveBitmap(
        String parFilename,
        Bitmap bitmap
    ) {
        try {
            outputStream = new FileOutputStream(parFilename);
            save(bitmap);
            outputStream.close();
        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }
    }

    public void saveBitmap(
        Bitmap bitmap,
        OutputStream outputStream
    ) {
        this.outputStream = outputStream;
        save(bitmap);
    }

    /*
     *  The saveMethod is the main method of the process. This method
     *  will call the convertImage method to convert the memory image to
     *  a byte array; method writeBitmapFileHeader creates and writes
     *  the bitmap file header; writeBitmapInfoHeader creates the
     *  information header; and writeBitmap writes the image.
     */
    private void save(
        Bitmap bitmap
    ) {
        try {
            convertImage(bitmap);
            writeBitmapFileHeader();
            writeBitmapInfoHeader();
            writeBitmap();
            // write to output stream
            outputStream.write(buffer.array());
        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }
    }

    /*
     * convertImage converts the memory image to the bitmap format (BRG).
     * It also computes some information for the bitmap info header.
     */
    private boolean convertImage(
        Bitmap bitmap
    ) {
        int pad;
        int width = bitmap.getWidth();
        int height = bitmap.getHeight();

        pixels = new int[width * height];

        bitmap.getPixels(
            pixels,
            0,
            width,
            0,
            0,
            width,
            height);

        pad = (4 - ((width * 3) % 4)) * height;
        biSizeImage = ((width * height) * 3) + pad;
        bfSize = biSizeImage + BITMAPFILEHEADER_SIZE +
            BITMAPINFOHEADER_SIZE;

        buffer = ByteBuffer.allocate(bfSize);
        biWidth = width;
        biHeight = height;
        return (true);
    }

    /*
     * writeBitmap converts the image returned from the pixel grabber to
     * the format required. Remember: scan lines are inverted in
     * a bitmap file!
     * Each scan line must be padded to an even 4-byte boundary.
     */
    private void writeBitmap() {
        int size;
        int value;
        int j;
        int i;
        int rowCount;
        int rowIndex;
        int lastRowIndex;
        int pad;
        int padCount;
        byte rgb[] = new byte[3];
        size = (biWidth * biHeight) - 1;
        pad = 4 - ((biWidth * 3) % 4);
        if (pad == 4)   // Bug correction
            pad = 0;    // Bug correction
        rowCount = 1;
        padCount = 0;
        rowIndex = size - biWidth;
        lastRowIndex = rowIndex;
        try {
            for (j = 0; j < size; j++) {
                value = pixels[rowIndex];
                rgb[0] = (byte) (value & 0xFF);
                rgb[1] = (byte) ((value >> 8) & 0xFF);
                rgb[2] = (byte) ((value >> 16) & 0xFF);
                buffer.put(rgb);
                if (rowCount == biWidth) {
                    padCount += pad;
                    for (i = 1; i <= pad; i++) {
                        buffer.put((byte) 0x00);
                    }
                    rowCount = 1;
                    rowIndex = lastRowIndex - biWidth;
                    lastRowIndex = rowIndex;
                } else
                    rowCount++;
                rowIndex++;
            }
            // Update the size of the file
            bfSize += padCount - pad;
            biSizeImage += padCount - pad;
        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }
    }

    /*
     * writeBitmapFileHeader writes the bitmap file header to the file.
     */
    private void writeBitmapFileHeader() {
        try {
            buffer.put(bfType);
            buffer.put(intToDWord(bfSize));
            buffer.put(intToWord(bfReserved1));
            buffer.put(intToWord(bfReserved2));
            buffer.put(intToDWord(bfOffBits));
        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }
    }

    /*
     * writeBitmapInfoHeader writes the bitmap information header
     * to the file.
     */
    private void writeBitmapInfoHeader() {
        try {
            buffer.put(intToDWord(biSize));
            buffer.put(intToDWord(biWidth));
            buffer.put(intToDWord(biHeight));
            buffer.put(intToWord(biPlanes));
            buffer.put(intToWord(biBitCount));
            buffer.put(intToDWord(biCompression));
            buffer.put(intToDWord(biSizeImage));
            buffer.put(intToDWord(biXPelsPerMeter));
            buffer.put(intToDWord(biYPelsPerMeter));
            buffer.put(intToDWord(biClrUsed));
            buffer.put(intToDWord(biClrImportant));
        } catch (Exception e) {
            Log.e("Exception", e.getMessage());
        }
    }

    /*
     * intToWord converts an int to a word, where the return
     * value is stored in a 2-byte array.
     */
    private byte[] intToWord(
        int parValue
    ) {
        byte retValue[] = new byte[2];
        retValue[0] = (byte) (parValue & 0x00FF);
        retValue[1] = (byte) ((parValue >> 8) & 0x00FF);
        return (retValue);
    }

    /*
     * intToDWord converts an int to a double word, where the return
     * value is stored in a 4-byte array.
     */
    private byte[] intToDWord(
        int parValue
    ) {
        byte retValue[] = new byte[4];
        retValue[0] = (byte) (parValue & 0x00FF);
        retValue[1] = (byte) ((parValue >> 8) & 0x000000FF);
        retValue[2] = (byte) ((parValue >> 16) & 0x000000FF);
        retValue[3] = (byte) ((parValue >> 24) & 0x000000FF);
        return (retValue);
    }
}

Answer 4

注意，上面的代码很慢。我发现要优化上面的代码，有必要在放置之前创建一个字节数组来存储所有数据。当然，我在 Xamarin C# 中工作，所以也许这就是原因。无论如何，这是我的 Xamarin 代码，以防万一有人遇到同样的问题。

      public class AndroidBmpUtil
        {

            private static int BMP_WIDTH_OF_TIMES = 4;
            private static int BYTE_PER_PIXEL = 3;

            /**
             * Android Bitmap Object to Window's v3 24bit Bmp Format File
             * @param orgBitmap
             * @param filePath
             * @return file saved result
             */
            public static byte[] ConvertAndroidBitmapByteArray(Bitmap orgBitmap, String filePath)
            {
                if (orgBitmap == null)
                {
                    return null;
                }

                if (filePath == null)
                {
                    return null;
                }

                //image size
                int width = orgBitmap.Width;
                int height = orgBitmap.Height;

                //image dummy data size
                //reason : the amount of bytes per image row must be a multiple of 4 (requirements of bmp format)
                byte[] dummyBytesPerRow = null;
                bool hasDummy = false;
                int rowWidthInBytes = BYTE_PER_PIXEL * width; //source image width * number of bytes to encode one pixel.
                if (rowWidthInBytes % BMP_WIDTH_OF_TIMES > 0)
                {
                    hasDummy = true;
                    //the number of dummy bytes we need to add on each row
                    dummyBytesPerRow = new byte[(BMP_WIDTH_OF_TIMES - (rowWidthInBytes % BMP_WIDTH_OF_TIMES))];
                    //just fill an array with the dummy bytes we need to append at the end of each row
                    for (int i = 0; i < dummyBytesPerRow.Length; i++)
                    {
                        dummyBytesPerRow[i] = (byte)0xFF;
                    }
                }

                //an array to receive the pixels from the source image
                int[] pixels = new int[width * height];

                //the number of bytes used in the file to store raw image data (excluding file headers)
                int imageSize = (rowWidthInBytes + (hasDummy ? dummyBytesPerRow.Length : 0)) * height;
                //file headers size
                int imageDataOffset = 0x36;

                //final size of the file
                int fileSize = imageSize + imageDataOffset;

                //Android Bitmap Image Data
                orgBitmap.GetPixels(pixels, 0, width, 0, 0, width, height);

                //ByteArrayOutputStream baos = new ByteArrayOutputStream(fileSize);
                ByteBuffer buffer = ByteBuffer.Allocate(fileSize);

                /**
                 * BITMAP FILE HEADER Write Start
                 **/
                buffer.Put((sbyte)0x42);
                buffer.Put((sbyte)0x4D);

                //size
                buffer.Put(writeInt(fileSize));

                //reserved
                buffer.Put(writeShort((short)0));
                buffer.Put(writeShort((short)0));

                //image data start offset
                buffer.Put(writeInt(imageDataOffset));

                /** BITMAP FILE HEADER Write End */

                //*******************************************

                /** BITMAP INFO HEADER Write Start */
                //size
                buffer.Put(writeInt(0x28));

                //width, height
                //if we add 3 dummy bytes per row : it means we add a pixel (and the image width is modified.
                buffer.Put(writeInt(width + (hasDummy ? (dummyBytesPerRow.Length == 3 ? 1 : 0) : 0)));
                buffer.Put(writeInt(height));

                //planes
                buffer.Put(writeShort((short)1));

                //bit count
                buffer.Put(writeShort((short)24));

                //bit compression
                buffer.Put(writeInt(0));

                //image data size
                buffer.Put(writeInt(imageSize));

                //horizontal resolution in pixels per meter
                buffer.Put(writeInt(0));

                //vertical resolution in pixels per meter (unreliable)
                buffer.Put(writeInt(0));

                buffer.Put(writeInt(0));

                buffer.Put(writeInt(0));

                /** BITMAP INFO HEADER Write End */
                int row = height;
                int col = width;
                int startPosition = (row - 1) * col;
                int endPosition = row * col;

                // This while loop is a lengthy process
                // Puts take a while so only do one by creating a big array called final
                byte[] final = new byte[0];
                while (row > 0)
                {
                    // This array is also used to cut down on time of puts
                    byte[] b = new byte[(endPosition - startPosition)*3];
                    int counter = 0;
                    for (int i = startPosition; i < endPosition; i++)
                    {

                        b[counter] = (byte)((pixels[i] & 0x000000FF));
                        b[counter + 1] = (byte)((pixels[i] & 0x0000FF00) >> 8);
                        b[counter + 2] = (byte)((pixels[i] & 0x00FF0000) >> 16);
                        counter += 3;
                    }
                    int finalPriorLength = final.Length;
                    Array.Resize<byte>(ref final, finalPriorLength + b.Length);
                    Array.Copy(b, 0, final, finalPriorLength, b.Length);

                    if (hasDummy)
                    {
                        finalPriorLength = final.Length;
                        Array.Resize<byte>(ref final, finalPriorLength + dummyBytesPerRow.Length);
                        Array.Copy(dummyBytesPerRow, 0, final, finalPriorLength, dummyBytesPerRow.Length);
                    }
                    row--;
                    endPosition = startPosition;
                    startPosition = startPosition - col;
                }
                buffer.Put(final);
                buffer.Rewind();

                IntPtr classHandle = JNIEnv.FindClass("java/nio/ByteBuffer");
                IntPtr methodId = JNIEnv.GetMethodID(classHandle, "array", "()[B");
                IntPtr resultHandle = JNIEnv.CallObjectMethod(buffer.Handle, methodId);
                byte[] result = JNIEnv.GetArray<byte>(resultHandle);
                JNIEnv.DeleteLocalRef(resultHandle);

                return result;
            }

            /**
             * Write integer to little-endian
             * @param value
             * @return
             * @throws IOException
             */
            private static byte[] writeInt(int value)
            {
                byte[] b = new byte[4];

                b[0] = (byte)(value & 0x000000FF);
                b[1] = (byte)((value & 0x0000FF00) >> 8);
                b[2] = (byte)((value & 0x00FF0000) >> 16);
                b[3] = (byte)((value & 0xFF000000) >> 24);

                return b;
            }

            /**
             * Write short to little-endian byte array
             * @param value
             * @return
             * @throws IOException
             */
            private static byte[] writeShort(short value)
            {
                byte[] b = new byte[2];

                b[0] = (byte)(value & 0x00FF);
                b[1] = (byte)((value & 0xFF00) >> 8);

                return b;
            }
        }
    }

调用代码如下：

using (FileStream outStream = new    FileStream(@yourFilePath, FileMode.Create))
{
    Bitmap Signature = Bitmap.CreateBitmap(user defined values...); 
    byte[] buffer = AndroidBmpUtil.ConvertAndroidBitmapByteArray(Signature, @yourFilePath); 

    // Actually create the file                                 
    outStream.Write(buffer, 0, buffer.Length);
}