@NonNull

private ByteArrayOutputStream flipImageHorizontally() {

    ByteBuffer buffer = image.getPlanes()[0].getBuffer();

    byte[] bytes = new byte[buffer.remaining()];

    buffer.get(bytes);

    final Bitmap origin = BitmapFactory.decodeByteArray(bytes, 0, bytes.length);

    Matrix matrix = new Matrix();

    matrix.preScale(-1.0f, 1.0f);

    Bitmap hFlip = Bitmap.createBitmap(origin, 0, 0, origin.getWidth(), origin.getHeight(), matrix, true);

    return hFlip;

}

/**

 * Returns a bitmap from subset of the source bitmap,

 * transformed by the optional matrix. The new bitmap may be the

 * same object as source, or a copy may have been made. It is

 * initialized with the same density and color space as the original

 * bitmap.

 *

 * If the source bitmap is immutable and the requested subset is the

 * same as the source bitmap itself, then the source bitmap is

 * returned and no new bitmap is created.

 *

 * The returned bitmap will always be mutable except in the following scenarios:

 * (1) In situations where the source bitmap is returned and the source bitmap is immutable

 *

 * (2) The source bitmap is a hardware bitmap. That is {@link #getConfig()} is equivalent to

 * {@link Config#HARDWARE}

 *

 * @param source   The bitmap we are subsetting

 * @param x        The x coordinate of the first pixel in source

 * @param y        The y coordinate of the first pixel in source

 * @param width    The number of pixels in each row

 * @param height   The number of rows

 * @param m        Optional matrix to be applied to the pixels

 * @param filter   true if the source should be filtered.

 *                   Only applies if the matrix contains more than just

 *                   translation.

 * @return A bitmap that represents the specified subset of source

 * @throws IllegalArgumentException if the x, y, width, height values are

 *         outside of the dimensions of the source bitmap, or width is <= 0,

 *         or height is <= 0, or if the source bitmap has already been recycled

 */

public static Bitmap createBitmap(@NonNull Bitmap source, int x, int y, int width, int height,

        @Nullable Matrix m, boolean filter) {

    int neww = width;

    int newh = height;

    Bitmap bitmap;

    Paint paint;

    Rect srcR = new Rect(x, y, x + width, y + height);

    RectF dstR = new RectF(0, 0, width, height);

    RectF deviceR = new RectF();

    if (m == null || m.isIdentity()) {

        bitmap = createBitmap(null, neww, newh, newConfig, source.hasAlpha(), cs);

        paint = null;   // not needed

    } else {

        final boolean transformed = !m.rectStaysRect();

        m.mapRect(deviceR, dstR);

        neww = Math.round(deviceR.width());

        newh = Math.round(deviceR.height());

        bitmap = createBitmap(null, neww, newh, transformedConfig,

                transformed || source.hasAlpha(), cs);

        paint = new Paint();

        paint.setFilterBitmap(filter);

        if (transformed) {

            paint.setAntiAlias(true);

        }

    }

    // The new bitmap was created from a known bitmap source so assume that

    // they use the same density

    bitmap.mDensity = source.mDensity;

    bitmap.setHasAlpha(source.hasAlpha());

    bitmap.setPremultiplied(source.mRequestPremultiplied);

    Canvas canvas = new Canvas(bitmap);

    canvas.translate(-deviceR.left, -deviceR.top);

    canvas.concat(m);

    canvas.drawBitmap(source, srcR, dstR, paint);

    canvas.setBitmap(null);

    if (isHardware) {

        return bitmap.copy(Config.HARDWARE, false);

    }

    return bitmap;

}

canvas.translate(-deviceR.left, -deviceR.top);

canvas.concat(m);

/**

 * Preconcats the matrix with the specified translation. M' = M * T(dx, dy)

 */

public boolean preTranslate(float dx, float dy) {

    nPreTranslate(native_instance, dx, dy);

    return true;

}

Matrix matrix = new Matrix();

matrix.preScale(-1.0f, 1.0f);

RectF dstR = new RectF(0, 0, width, height);

Canvas canvas = new Canvas(bitmap);

canvas.translate(-deviceR.left, -deviceR.top);

canvas.concat(m);

canvas.drawBitmap(source, srcR, dstR, paint);

m.mapRect(deviceR, dstR);