type TColor is new Interfaces.Unsigned_32;
   type AColor is access all TColor;

   type TBitmap is new Controlled with record
      Handle	: HBITMAP;
      DC	: HDC;
      Mem	: aliased AColor; -- или удобнее aliased PVOID?
      SizeX, SizeY, Depth	: integer;
   end record;

   function Get_Pixel(B: TBitmap; X, Y: integer) return AColor;
   -- возвращает указатель на пиксел с данными координатами
   pragma Inline(Get_Pixel);

   function Get_Pixel(B: TBitmap; X, Y: integer) return AColor is
   begin
      Assert((X >= 0) and (X < B.SizeX) and (Y >= 0) and (Y < B.SizeY));
      return B.Mem + X + Y * B.SizeX;
   end;

 procedure Set_Size(B: in out TBitmap; X, Y, D: integer) is
      BI: aliased BitmapInfo;
      ScreenDC: HDC;
      i: INT;
      o: HGDIOBJ;
      p: PVOID;
      
      type aaColor is access all aColor;
      type PPVoid is access all PVOID;
      
      function To_PVOID is new Ada.Unchecked_Conversion(PBitmapInfo, PVOID);
      function To_PPVOID is new Ada.Unchecked_Conversion(aaColor, PPVOID);
   begin
      Finalize(B);
      
      p := MemSet(To_PVOID(BI'Unchecked_Access), 0, BI'Size / 8);

      BI.bmiHeader.biSize	:= BI.bmiHeader'Size / 8;
      BI.bmiHeader.biWidth	:= LONG(X);
      BI.bmiHeader.biHeight	:= LONG(Y);
      BI.bmiHeader.biPlanes	:= 1;
      BI.bmiHeader.biBitCount	:= USHORT(D);

      ScreenDC := GetDC(System.Null_Address);
      B.DC := CreateCompatibleDC(ScreenDC);
      B.SizeX := X;
      B.SizeY := Y;
      B.Depth := D;
      B.Handle := CreateDIBSection( B.DC, BI'Unchecked_Access, DIB_RGB_COLORS, To_PPVOID(B.Mem'Access), System.Null_Address, 0);
      o := SelectObject(B.DC, B.Handle);
      i := ReleaseDC(System.Null_Address, ScreenDC);
   end;

   type AColor_Array is array (Natural range <>) of aliased AColor;
   type TBitmap is new Controlled with record
      Handle	: HBITMAP;
      DC	: HDC;
      SizeX, SizeY, Depth	: integer;
      
      Mem	: AColor_Array (0 .. Win32.ANYSIZE_ARRAY);
   end record;

   type TColor is new Interfaces.Unsigned_32;

   type TColor_Array is array (Integer range 0 .. Win32.ANYSIZE_ARRAY) of aliased TColor;
   type PTColor_Array is access all TColor_Array;
   
   type TBitmap is new Controlled with record
      Handle	: HBITMAP;
      DC	: HDC;
      SizeX, SizeY, Depth	: integer;
      
      Mem	: aliased Win32.PVOID;      
   end record;
   
   function Get_Pixel(B: TBitmap; X, Y: integer) return TColor;
   -- возвращает САМ ПИКСЕЛ с данными координатами
   pragma Inline(Get_Pixel);


   --  Вызов CreateDIBSection будет проходить так:

      pBuffer : aliased PVOID;
      -- ...
      B.Handle := Win32.Wingdi.CreateDIBSection (B.DC, BI'Unchecked_Access,
                                                 DIB_RGB_COLORS, pBuffer'Access,
                                                 System.Null_Address, 0);
      B.Mem := pBuffer;

   -- , а сама реализация GetPixel - проста до безобразия:

   function Get_Pixel(B: TBitmap; X, Y: integer) return TColor is
      function To_PTColorArray is new Ada.Unchecked_Conversion (Win32.PVOID, PTColor_Array);
      Ptr : constant PTColor_Array := To_PTColorArray (B.Mem);
   begin
      pragma Assert((X >= 0) and (X < B.SizeX) and (Y >= 0) and (Y < B.SizeY));
      
      return Ptr.all(X + Y * B.SizeX);
   end;

SetPixel(((GetPixel(x, y) and $FEFEFE) + (Txr and $FEFEFE)) shr 1) 

P := GetPixelAddr(x, y);
P^ := (((P^ and $FEFEFE) + (Txr and $FEFEFE)) shr 1);

PX := PColor(PChar(PY) + i1 shl 2); 
for i := i1 to i2 do begin
  PX^ := PColor(PChar(Txr.Mem) + ((tx shr 16) + (ty shr 16) shl Txr.OrdX) shl 2)^;
  inc(PX);
  inc(tx, dtx);
  int(ty, dty);
end;
Inc(PY, Buf.SizeY);

   Max_X : constant Integer := 1024;  -- какие-то значения, заведомо бОльшие
   Max_Y : constant Integer := 1024;  -- чем максимальный размер секции.
   procedure Do_It (B : TBitmap) is
      type Flat_Type is array(1 .. Max_X * Max_Y) of TColor;
      Flat_Array : Flat_Type;
      for Flat_Array'Address use B.Mem;  -- Absolute, ага...
   begin
      -- ... А тут тебе карт-бланш, работай с массивом по индексу, как тебе угодно
      -- только следи за границами, а то такого натворить можно...
   end Do_It;

with System; use System;
with System.Storage_Elements;
with System.Address_To_Access_Conversions;
with Interfaces; use Interfaces;

with Ada.Text_IO;

procedure Main is
   
   type my_rec is record
      R, G, B : Interfaces.Unsigned_8;
   end record;
   my_arr : array(1 .. 10) of aliased my_rec := (others => (others => 0));
   
   package RecPtr is new System.Address_To_Access_Conversions (My_Rec);  
   PArr : RecPtr.Object_Pointer;
   
   subtype Offset is System.Storage_Elements.Storage_Offset;
   function "+" (A : System.Address; I : Offset ) return Address
                 renames System.Storage_Elements."+";

begin   
   for i in my_arr'Range loop
      Ada.Text_IO.Put_Line(
                           Unsigned_8'Image(my_arr(i).R) & " " &
                           Unsigned_8'Image(my_arr(i).G) & " " &
                           Unsigned_8'Image(my_arr(i).B) & " "
                          );
   end loop;
   
   PArr := my_arr(1)'Unchecked_Access;
   for i in my_arr'Range loop
      parr.all.R := parr.all.R + 10;
      parr := RecPtr.To_Pointer(RecPtr.To_Address(PArr) + 3);  -- Обе эти функции - Intrinsic
   end loop;
   
   for i in my_arr'Range loop
      Ada.Text_IO.Put_Line(
                           Unsigned_8'Image(my_arr(i).R) & " " &
                           Unsigned_8'Image(my_arr(i).G) & " " &
                           Unsigned_8'Image(my_arr(i).B) & " "
                          );
   end loop;
end Main;

 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 0  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 
 10  0  0 

   type my_rec is record
      R, G, B : Interfaces.Unsigned_16;
   end record;
   for my_rec'alignment use 4;

   SizeR : constant Integer := Unsigned_16'Size;
   SizeG : constant Integer := Unsigned_16'Size;
   SizeB : constant Integer := Unsigned_16'Size;
   
   D : constant integer := My_Rec'Alignment * 
     (((SizeR + SizeG + SizeB) / Storage_Unit + My_Rec'Alignment - 1) / My_Rec'Alignment);
  -- ...

  parr := RecPtr.To_Pointer(RecPtr.To_Address(PArr) + Offset(D));