Mutlithreading

[code_glitch]

In my quest for Prometheus_Audio I came across a small nuisance in how OpenAl works... Or rather common sense: I have to update buffers at least once every second at least.

Prometheus is aimed at beginners, and I must say I'm not sure I want to tell them that if they want audio you have to call the update procedure at least once a second, depending on the bit rate of you audio file.

My solution was to have Prometheus make a thread that would only run that loop.
However, I did poke around for multi-threading and drew one major conclusion: headache. Anyways, always the optimist I thought it was easier than it looked and gave it a go. And guess what: I gots a headache too now...

My question is: does anyone have a snippet that launches a thread that simply steps through a loop non-stop and how to get it working?

Any help would be much appreciated; I'm totally confused d now...

cheers,
code_glitch

[code_glitch]

Just another thing: I just finished this new version of Prometheus_Audio in OpenAl but no matter what I try I only get segmentation faults, exit codes and no sound:

unit Prometheus_Audio;

{$Mode ObjFpc}

interface

uses
    sysutils,
    Classes,
    
    OpenAl;

const
    ID_RIFF 				=	'RIFF';
    ID_WAVE 				=	'WAVE';
    ID_fmt  				=	'fmt ';
    ID_data 				=	'data';

    al_bufcount           		=	100;
    al_polltime           		=	1000;

    BufferSize				=	8192;
    
    MAX_AUDIOSTREAMS:	Int64		=	600;

type
    TAlData = record
	    Al_Device:		PALCdevice;
	    Al_Context:		PALCcontext;
	    Al_Source:		ALuint;
	    Al_Format:		Integer;
	    Al_Buffers:		array[0..al_bufcount-1] of ALuint;
	    Al_Bufsize:		Longword;
	    Al_Readbuf:		Pointer;
	    Al_Rate:		Longword;
  
	    Codec_bs:		Longword;
	    Queued:		Integer;
	end;
    TRiffHeader = record
	    ID:			array [0..3] of char;
	    Size:		Longword;
	    Format:		array [0..3] of char;
	end;
    TDataChunk = record
	    Id:			array [0..3] of char;
	    Size:		Longword;
	end;
    TWaveFormat = record
	    Id:			array [0..3] of char;
	    Size:		Longword;
	    Format:		Word;
	    Channels:		Word;
	    SampleRate:		Longword;
	    ByteRate:		Longword;
	    BlockAlign:		Word;
	    BitsPerSample:	Word;
	end;
    Audio = object
	    Initialized:	Boolean;
	    Loaded: 		Boolean;
	    ChunkData:		TDataChunk;
	    ChunkPos:		Int64;
	    Pos:		Int64;
	    EOF:		Boolean;
	    fStream:		TStream;
	    
	    Result:		Boolean;
	    
	    Fmt: 		TWaveFormat;
	    AlData:		TAlData;
	    
	    function ReadBuf(var Buffer; BufferSize: Integer): Integer;
	    procedure Initialize();
	end;
    pAudio = ^Audio;
    PrometheusAudioRec = record
	    AudioStream:	array [1..600] of pAudio;
	    ActiveStream:	array [1..600] of Boolean;
	    TotalStreams:	Int64;
	end;
	
var
    PrometheusAudio: PrometheusAudioRec;

procedure LoadAudio(Src: String; Audio: pAudio);
procedure PlayAudio(Audio: pAudio);
procedure AudioProcess();

implementation

function AudioExists(Audio: pAudio): Boolean;
var
    i: Int64;
    
begin
    i := 0;
    repeat
	i := i + 1;
	until (i >= MAX_AUDIOSTREAMS) or (@PrometheusAudio.AudioStream[i] = @Audio);
	
    if (i >= MAX_AUDIOSTREAMS) and (@PrometheusAudio.AudioStream[i] <> @Audio) then
	AudioExists := False
    else
	AudioExists := True;
end;

function Min(a,b: Integer): Integer;
begin
  if a<b then Result:=a
  else Result:=b;
end;

procedure Audio.Initialize();
begin
    
    AlData.Al_Bufsize := BufferSize;
    AlData.Al_Format := AL_FORMAT_STEREO16;
    AlData.Codec_bs := 2;
    AlData.Al_Device := alcOpenDevice(nil);
    AlData.Al_Context := alcCreateContext(AlData.Al_Device, nil);
    alcMakeContextCurrent(AlData.Al_Context);
    AlData.Al_Rate := 44100;
    
    AlDistanceModel( Al_Inverse_Distance_Clamped);
    AlGenSources(1, @AlData.Al_Source);
    AlGenBuffers(al_bufcount, @AlData.Al_Buffers);
    
    GetMem(AlData.Al_Readbuf, AlData.Al_Bufsize);
    
    Initialized := True;
end;

function Audio.ReadBuf(var Buffer; BufferSize: Integer): Integer;
var
    Sz:		Integer;
    P:		PByteArray;
    I:		Integer;

begin
    if Initialized = False then
	Initialize();
	
    FillChar(Buffer, BufferSize, 0);
    Result := 0;
    
    if eof then Exit;
    
    p := @Buffer;
     
    I := 0;
    while (not EOF) and (i < BufferSize) do
	begin
	    if ChunkPos >= ChunkData.Size then
		begin
		    if Pos < 0 then
			fStream.Position := SizeOf(TRiffHeader) + Int64(Fmt.Size) + SizeOf(TDataChunk)
		    else
			fStream.Position := Pos + ChunkData.Size + SizeOf(ChunkData);
		    
		    EOF := pos >= fStream.Size;
		    if not EOF then
			begin
			    Pos := fStream.Position;
			    Sz := fStream.Read(ChunkData, SizeOf(ChunkData));
			    ChunkData.Size := LEtoN(ChunkData.Size);
			    if (Sz <> SizeOf(ChunkData)) or (ChunkData.Id <> ID_data) then
				ChunkPos := ChunkData.Size
			    else
				ChunkPos := 0;
			end;
		end
	    else
		begin
		    Sz := Min(BufferSize, ChunkData.Size - ChunkPos);
		    fStream.Position := Pos + SizeOf(ChunkData) + ChunkPos;
		    Sz := fStream.Read(P[I], Sz);
		    if Sz < 0 then
			exit;
		    inc(ChunkPos, Sz);
		    inc(I, Sz);
		end;
	end;
end;

procedure LoadAudio(Src: String; Audio: pAudio);
var
    Riff:	TRiffHeader;

begin
    if Audio^.Initialized = False then
	Audio^.Initialize;
	
    Audio^.fStream := TFileStream.Create(Src, fmOpenRead);
    
    Audio^.Loaded := True;
    
    try
	Audio^.Result := Audio^.fStream.Read(Riff, SizeOf(Riff)) = SizeOf(Riff);
	Riff.Size := LEtoN(Riff.Size);
	
	Audio^.Result := Audio^.Result and (Riff.ID = ID_RIFF) and (Riff.Format = ID_WAVE);
	
	if not Audio^.Result then
	    Exit;
	
	Audio^.Result := Audio^.fStream.Read(Audio^.Fmt, SizeOf(Audio^.Fmt)) = SizeOf(Audio^.Fmt);
	Audio^.Fmt.Size := LEtoN(Audio^.Fmt.Size);
	Audio^.Fmt.Format := LEtoN(Audio^.Fmt.Format);
	Audio^.Fmt.Channels := LEtoN(Audio^.Fmt.Channels);
	Audio^.Fmt.SampleRate := LEtoN(Audio^.Fmt.SampleRate);
	Audio^.Fmt.ByteRate := LEtoN(Audio^.Fmt.ByteRate);
	Audio^.Fmt.BlockAlign := LEtoN(Audio^.Fmt.BlockAlign);
	Audio^.Fmt.BitsPerSample := LEtoN(Audio^.Fmt.BitsPerSample);
	
	Audio^.Result := Audio^.Fmt.ID = ID_FMT;
	Audio^.Pos := -1;
    except
	Audio^.Result := False;
	Exit;
    end;
    
    if AudioExists(Audio) = False then
	begin
	    PrometheusAudio.ActiveStream[PrometheusAudio.TotalStreams + 1] := True;
	    PrometheusAudio.AudioStream[PrometheusAudio.TotalStreams + 1] := Audio;
	    PrometheusAudio.TotalStreams := PrometheusAudio.TotalStreams + 1;
	end;
end;

procedure PlayAudio(Audio: pAudio);
var
    i: 		Int64;

begin
    alSourceStop(Audio^.AlData.Al_Source);
    alSourceRewind(Audio^.AlData.Al_Source);
    alSourcei(Audio^.AlData.Al_Source, Al_Buffer, 0);
    
    
    for i := 0 to al_bufcount - 1 do
	begin
	    if Audio^.ReadBuf(Audio^.AlData.Al_Readbuf^, Audio^.AlData.Al_Bufsize) = 0 then
		break;
	    alBufferData(Audio^.AlData.Al_Buffers[i], Audio^.AlData.Al_Format, Audio^.AlData.Al_Readbuf, Audio^.AlData.Al_BufSize, Audio^.AlData.Al_Rate);
	    alSourceQueueBuffers(Audio^.AlData.Al_Source, 1, @Audio^.AlData.Al_Buffers[i]);
	end;
    
    
    alSourcei(Audio^.AlData.Al_Source, Al_Looping, AL_False);
    alSourcePlay(Audio^.AlData.Al_Source);
end;

function AlSubProcess(Audio: pAudio): Boolean;
var
    Processed:	ALint;
    Buffer:	ALuint;
    Sz:		Integer;

begin
    
    alGetSourcei(Audio^.AlData.Al_Source, Al_Buffers_Processed, Processed);
    while (processed > 0) and (processed <= al_bufcount) do
	begin
	    alSourceUnqueueBuffers(Audio^.AlData.Al_Source, 1, @Buffer);
	    
	    Sz := Audio^.ReadBuf(Audio^.AlData.Al_Readbuf, Audio^.AlData.Al_Bufsize);
	    if Sz <= 0 then
		begin
		    Exit(False);
		end;
	    
	    alBufferData(Buffer, Audio^.AlData.Al_Format, Audio^.AlData.Al_Readbuf, Sz, Audio^.AlData.Al_Rate);
	    alSourceQueueBuffers(Audio^.AlData.Al_Source, 1, @Buffer);
	    
	    Dec(Processed);
	end;
    
    Result := True;
end;

procedure AudioProcess();
var
    i: Int64;

begin
    i := 0;
    repeat
	 i := i + 1;
	 if PrometheusAudio.ActiveStream[i] = True then
	    alSubProcess(PrometheusAudio.AudioStream[i]);
	until i >= MAX_AUDIOSTREAMS;
end;

end.

can any of you OpenAl savvy people see what's gone wrong in this? I suspect PlayAudio, LoadAudio and Audio.Initialize but cant see any errors... Sorry for the long code, but I trimmed it down as much as I could. Cheers for any help.

[JSoftware]

Sure. Here's a snippet using TThread

type
 TSomeThreadClass = class(TThread)
 protected
  procedure Execute; override;
 end;

procedure TSomeThreadClass.Execute;
begin
   //Initialize Stuff
   while not Terminated do
   begin
      //Do something
      //You may want to put a sleep(10) or something depending on how long time the task takes
   end;
   //Clean up stuff
end;

...

var SoundThread: TSomeThreadClass;
begin
   SoundThread := TSomeThreadClass.Create(false); //Create the thread, s
   ...
   SoundThread.Terminate; //Tell thread to stop
   SoundThread.WaitFor; //Wait until thread exits
   SoundThread.Free;
end;

[code_glitch]

cheers for that. Will start experimenting ASAP.

[arthurprs]

I had similar problems when I was coding http://www.1clickmusic.net on the past, but with DirectSound. Your solution is the right one

[code_glitch]

Any thoughts on whats causing the audio screwup I posted about earlier? I posted it in this thread to avoid clutter since they were a bit related...