Very simple conversion of bitmap to indexed bitmap

using System.Drawing;
using System.Drawing.Imaging;

1. Never return an object that implements an IDisposable pattern i.e. requires garbage collection
2. Never implement a method with objects that contain lifetime resources without exception handling

private static void ToIndexed(Bitmap source, PixelFormat format, out Bitmap result)
   {
       result = null;
       try
       {
           unsafe
           {
               Rectangle rectangle = new Rectangle(0, 0, source.Width, source.Height);
               result = new Bitmap(source.Width, source.Height, format);

               BitmapData sourceData = source.LockBits(rectangle,
                       ImageLockMode.ReadOnly, source.PixelFormat),
                   resultData = result.LockBits(rectangle,
                       ImageLockMode.WriteOnly, format);

               int sourceFlags = sourceData.Stride * sourceData.Height,
                   resultFlags = resultData.Stride * resultData.Height;

               byte* sourceBuffer = (byte*)sourceData.Scan0.ToPointer(),
                   resultBuffer = (byte*)resultData.Scan0.ToPointer();

               int offset = sourceFlags / resultFlags;
               for (int i = 0; i < sourceFlags; i++)
               {
                   resultBuffer[i / offset] = sourceBuffer[i];
               }

               result.UnlockBits(resultData);
               source.UnlockBits(sourceData);
           }

       }
       catch (Exception e)
       {
           result?.Dispose();
           throw;
       }
   }

static void Main(string[] args)
{
    try
    {
        using (Bitmap bm = new Bitmap(10, 10))
        {
            Bitmap res;
            ToIndexed(bm, PixelFormat.Alpha, res);

                . . . .

        }
    }
    catch (Exception e)
    {
        Console.WriteLine(e);
        throw;
    }
}

PixelFormat fastFormat = PixelFormat.Format4bppIndexed;
            Bitmap bitmap = (Bitmap)Image.FromFile(imagePath);
           
            Stopwatch stopWatch = new Stopwatch();
            stopWatch.Start();
            FastBitmap myFastBitmap = new FastBitmap(bitmap);
            myFastBitmap.LockBits();
            int width = myFastBitmap.Width, height = myFastBitmap.Height;
            FastBitmapBuilder myFastBitmapBuilder = new FastBitmapBuilder(
            width, height, fastFormat);
            myFastBitmapBuilder.LockBits();
            for (int i = 0; i < myFastBitmap.Flags; i++)
            {
                myFastBitmapBuilder[i / (myFastBitmap.Flags 
                / myFastBitmapBuilder.Flags)] = myFastBitmap[i];
            }


            bitmap = myFastBitmapBuilder;

            stopWatch.Stop();
            Console.WriteLine($"{stopWatch.ElapsedMilliseconds} ms");
            //Console writes 1102 ms

/// <summary>
        /// Inverts the specified <see cref="Bitmap"/>
        /// </summary>
        /// <param name="bitmap">Bitmap.</param>
        public static void Invert(this Bitmap bitmap)
        {
            //use the fastbitmap class to get pointer
            FastBitmap fast = new FastBitmap(bitmap);
            // lock the bits in place so we can manipulate image data
            fast.LockBits();
            for (int i = 0; i < fast.Flags; i++)
            {
                // set pixels of fast bitmap to negative value
                fast[i] = (byte)-fast[i];
            }
            fast.UnlockBits();
            // bitmap has negative pixels(inverted) 
        }