Re: Allocation questions

[Martin <martin.dowie@btopenworld.com>]

On May 28, 10:46 am, Olivier Scalbert <olivier.scalb...@algosyn.com>
wrote:
> Hello,
>
> In the context of my small audio project, I need to create an object to
> introduce a delay in a signal. With some of these objects and other
> stuff it is possible to simulate nice reverberation.
>
> Here is the code (As delay is a reserved word in Ada, I use Delay_T as I
> found nothing better !):
>
> package audio.effect is
>
>      type Sample is new Float;
>      type Time   is new Float;
>
>      type Samples_Array is array (Positive range <>) of Sample;
>
>      type Delay_T is tagged record
>          Delay_Time: Time;
>          Output    : Sample;
>          Samples   : access Samples_Array;
>      end record;
>
>      function Create_Delay (Time_Value: Time) return Delay_T;
>
>      procedure Input (D: Delay_T; Input: Sample);
>      function Output (D: Delay_T) return Sample;
>      procedure  Next (D: Delay_T); -- compute next output
>
> end audio.effect;
>
> package body audio.effect is
>
>      function Create_Delay(Time_Value: Time) return Delay_T is
>          Result:      Delay_T;
>          Nb_Samples:  Integer;
>      begin
>          Result.Delay_Time := Time_Value;
>          Nb_Samples := Integer(Time_Value * 44_100.0);
>          Result.Samples := new Samples_Array(1..Nb_Samples);
>          Result.Output  := 0.0;
>          return Result;
>      end Create_Delay;
>
>      procedure Input (D: Delay_T; Input: Sample) is
>      begin
>          null; --TBD
>      end Input;
>
>      function Output(D: Delay_T) return Sample is
>      begin
>          return D.Output;
>      end Output;
>
>      procedure Next(D: Delay_T) is
>      begin
>          null; --TBD
>      end Next;
>
> end audio.effect;
> -- --------------------------------
> Here are my questions:
>
> 1) Is there a way to avoid the dynamic array allocation, as I do not
> know the Time_Value at compile time ?

You could look at Ada.Container.Vectors and the Reserve_Capacity
subprogram. The container libraries should offer perfectly acceptable
performance, esp if you only need to reserve once.

Or you could use a discriminant:

   type Samples (No_Of_Samples : Natural := 0) is
      record
         S : array (1 .. No_Of_Samples) of Sample;
      end record;


> 2) Is it possible to release the array automatically when the Delay
> object died ?

Checkout package Ada.Finalization.


> 3) I have read that there is a program call gnatmem to detect memory
> leaks. Is there somewhere a package for Linux (Debian) ?

Sorry, no idea.

Cheers
-- Martin