u_vcmp3demo_main.pas

Voice Commnucation Components for Delphi

	bEnableVBR := c_checkBox_enableVBR.Checked;
	nVBRQuality := c_comboBox_vbrQuality.ItemIndex;
	//
	if (c_checkBox_enableVBR.Checked) then begin
	  //
	  dwVbrAbr_bps := avBR;
	  if (0 < avBR) then
	    nVbrMethod := VBR_METHOD_ABR
	  else
	    nVbrMethod := VBR_METHOD_NEW
	end
	else
	  nVbrMethod := VBR_METHOD_NONE;
	//
	bNoRes := c_checkBox_disBRS.Checked;
	bStrictIso := false;
	//btReserved := 0;
      end;
      config := @lameConfig;
    end;

    // --  --
    if ((nil = config) and (f_vorbisEncode = f_encoder)) then begin
      //
      fillChar(vorbisConfig, sizeOf(vorbisConfig), #0);
      //
      vorbisConfig.r_numOfChannels := waveIn.pcm_NumChannels;
      vorbisConfig.r_samplingRate := samplesRate;
      //
      if (c_checkBox_enableVBR.Checked) then begin
	//
	vorbisConfig.r_encodeMethod := vemVBR;
	vorbisConfig.r_quality := (10 - c_comboBox_vbrQuality.ItemIndex - 1.999) / 10;
      end
      else begin
	//
	vorbisConfig.r_encodeMethod := vemRateManage;
	vorbisConfig.r_manage_minBitrate := -1;
	vorbisConfig.r_manage_normalBitrate := avBR * 1000;
	vorbisConfig.r_manage_maxBitrate := -1;
	vorbisConfig.r_manage_mode := OV_ECTL_RATEMANAGE_AVG;
      end;
      //
      config := @vorbisConfig;
    end;

    //
    if (nil <> config) then begin
      //
      f_vorbisHP := 3;	// need to set this before opening the encoder
      if (BE_ERR_SUCCESSFUL = f_encoder.setConfig(config)) then begin
	//
	if (BE_ERR_SUCCESSFUL = f_encoder.open()) then begin
	  //
	  case (f_encoderDestIndex) of

	    0: begin
	      //
	      c_edit_destFile.enabled := false;
	      deleteFile(pChar(c_edit_destFile.text));
	      //
	      c_button_destBrowse.enabled := false;
	      //
	      ok := true;
	    end;

	    1, 2: begin
	      //
	      case (f_ipComponentType[tipeEnc]) of

		tiptSrv: begin
		  //
		  f_sockClients[tipeEnc].clear();
		  f_sockId[tipeEnc] := f_socks.createServer(c_edit_encPortNumber.text, index2proto(c_comboBox_encSocketType.itemIndex), true, 5, 0);
		  ok := (0 < f_sockId[tipeEnc]);
		end;

		tiptCln: begin
		  //
		  f_sockId[tipeEnc] := f_socks.createConnection(c_edit_encSrvAddr.text, c_edit_encPortNumber.text, f_sockConnId[tipeEnc], index2proto(c_comboBox_encSocketType.itemIndex));
		  ok := (0 < f_sockId[tipeEnc]) and (0 < f_sockConnId[tipeEnc]);
		end;

		else
		  ok := false;

	      end;
	      //
	      c_edit_encSrvAddr.enabled := false;
	      c_edit_encPortNumber.enabled := false;
	      c_comboBox_encSocketType.enabled := false;
	    end;

	    else
	      ok := false;

	  end;
	  //
	  if (ok) then begin
	    //
	    a_encode_stop.enabled := true;
	    a_encode_start.enabled := false;
	    //
	    waveIn.open();
	    waveIn.waveInDevice.assignStream(false, nil);
	  end
	  else begin
	    //
	    c_button_encodeStop.click();
	    c_statusBar_main.panels[1].text := 'TCP/IP operation failed';
	    f_encoder := nil;
	  end;
	  //
	end
	else begin
	  //
	  c_statusBar_main.panels[1].text := 'Open fails, error code: ' + int2str(f_encoder.errorCode, 16);
	  f_encoder := nil;
	end
      end
      else begin
	//
	c_statusBar_main.panels[1].text := 'Config fails, error code: ' + int2str(f_encoder.errorCode, 16);
	f_encoder := nil;
      end;
    end;
  end
  else
    c_statusBar_main.panels[1].text := 'Please select an encoder.';
  //
end;

// --  --
procedure Tc_form_main.a_encode_stopExecute(Sender: TObject);
begin
  if (nil <> f_encoder) then begin
    //
    waveIn.close();
    f_encoder.close();
    //
    a_encode_stop.enabled := false;
    a_encode_start.enabled := true;
    //
    case (f_encoderDestIndex) of

      0: begin
	//
	c_edit_destFile.enabled := true;
	c_button_destBrowse.enabled := c_edit_destFile.enabled;
	//
	if (nil <> f_oggOutFile) then
	  flushOgg();
	//
	freeAndNil(f_oggOutFile);
      end;

      1, 2: begin
	//
	f_ipComponentReady[tipeEnc] := false;
	f_sockClients[tipeEnc].clear();
	//
	if (0 < f_sockId[tipeEnc]) then
	  f_socks.closeThread(f_sockId[tipeEnc]);
	//
	f_sockId[tipeEnc] := 0;
	f_sockConnId[tipeEnc] := 0;
	//
	c_edit_encSrvAddr.enabled := true;
	c_edit_encPortNumber.enabled := true;
	c_comboBox_encSocketType.enabled := true;
      end;

    end;
    //
    f_encoder := nil;
  end;
end;

// --  --
procedure Tc_form_main.a_decode_startExecute(Sender: TObject);
var
  ok: bool;
  freq: int;
  volume: int;
  pan: int;
  flags: DWORD;
begin
  a_decode_start.enabled := false;
  //
  c_statusBar_main.panels[1].text := '';
  f_decoderIndex := c_comboBox_decoder.itemIndex;	// 0 - Ogg/Vorbis
							// 1 - BASS
							// 2 - MpgLib
  //
  f_ipComponentReady[tipeDec] := false;
  case (c_comboBox_decoderSource.itemIndex) of

    1: f_ipComponentType[tipeDec] := tiptCln;
    2: f_ipComponentType[tipeDec] := tiptSrv;

  end;
  //
  f_decoderSourceIndex := c_comboBox_decoderSource.itemIndex;
  case (f_decoderSourceIndex) of

    0: begin	// file

      ok := true;
      case (f_decoderIndex) of

	0: begin	// Ogg/Vorbis library
	  //
	  f_oggInFile := unaOggFile.create(c_edit_sourceFile.text, -1, GENERIC_READ);
	  if (0 <> f_oggInFile.errorCode) then begin
	    //
	    c_statusBar_main.panels[1].text := 'OGG File Error code: ' + int2str(f_oggInFile.errorCode);
	    ok := false;
	  end
	  else begin
	    // create decoder as well
	    f_vorbisDecode := unaVorbisDecoder.create();
	    f_vorbisDecode.onDataAvailable := myOnDecoderDataAvail;
	    //
	    // init ogg reader and vorbis decoder
	    f_oggInFile.sync_init();
	    //
	    if (0 = f_oggInFile.vorbis_decode_int(f_vorbisDecode)) then begin
	      // init and open waveOut device
	      waveOut.pcm_samplesPerSec := f_vorbisDecode.vi.rate;
	      waveOut.pcm_bitsPerSample := 16;	// vorbis always has 16 bits
	      waveOut.pcm_numChannels := f_vorbisDecode.vi.channels;
	      //
	      f_vorbisDecode.decode_initBuffer(8912);
	    end
	    else begin
	      //
	      c_statusBar_main.panels[1].text := 'OGG Decoder Error code: ' + int2str(f_oggInFile.errorCode);
	      ok := false;
	    end;
	  end;
	  //
	  if (not ok) then
	    a_decode_stopExecute(sender);
	end;

	1: begin	// BASS
	  //
	  f_bassFile := unaBassStream.create(f_bassDecoder);
	  if (f_bassFile.createStream(c_edit_sourceFile.text, 0, 0, BASS_STREAM_DECODE)) then begin
	    //
	    f_bassFile.asChannel.get_attributes(freq, volume, pan);
	    flags := f_bassFile.asChannel.get_flags();
	    //
	    waveOut.pcm_samplesPerSec := freq;
	    //
	    if (0 <> (BASS_SAMPLE_8BITS and flags)) then
	      waveOut.pcm_bitsPerSample := 8
	    else
	      waveOut.pcm_bitsPerSample := 16;
	    //
	    if (0 <> (BASS_SAMPLE_MONO and flags)) then
	      waveOut.pcm_numChannels := 1
	    else
	      waveOut.pcm_numChannels := 2;
	    //
	    f_bassDecodedSize := 0;
	  end
	  else begin
	    //
	    c_statusBar_main.panels[1].text := 'File decoding error: ' + int2str(f_bassDecoder.get_errorCode());
	    freeAndNil(f_bassFile);
	    ok := false;
	    //
	  end;
	end;

	2: begin	// MpgLib
	  //
	  f_mpgFile := fileCreate(c_edit_sourceFile.text, false, true);
	  ok := (INVALID_HANDLE_VALUE <> f_mpgFile) and (0 <> f_mpgFile);
	  //
	  if (ok) then
	    f_mpgDecoder.open()
	  else
	    f_mpgFile := 0;
	  //
	  f_mpgDecodedSize := 0;
	end;

	else begin
	  //
	  c_statusBar_main.panels[1].text := 'Unknown decode library';
	  a_decode_start.enabled := true;
	end;

      end;

    end;

    1, 2: begin	// TCP/IP stream
      //
      case (f_ipComponentType[tipeDec]) of

	tiptSrv: begin
	  //
	  f_sockClients[tipeDec].clear();
	  f_sockId[tipeDec] := f_socks.createServer(c_edit_decSrvPort.text, index2proto(c_comboBox_decSrvSocketType.itemIndex), true, 5, 0);
	  ok := (0 < f_sockId[tipeDec]);
	end;

	tiptCln: begin
	  //
	  f_sockId[tipeDec] := f_socks.createConnection(c_edit_decSrvAddr.text, c_edit_decSrvPort.text, f_sockConnId[tipeDec], index2proto(c_comboBox_decSrvSocketType.itemIndex));
	  ok := (0 < f_sockId[tipeDec]) and (0 < f_sockConnId[tipeDec]);
	end;

	else
	  ok := false;

      end;
      //
      // aslo open the decoder (only mpgDecoder is supported)
      if (ok) then
	f_mpgDecoder.open()
      else
	f_mpgFile := 0;
      //
      f_mpgDecodedSize := 0;
      //
      c_edit_decSrvAddr.enabled := false;
      c_edit_decSrvPort .enabled := false;
      c_comboBox_decSrvSocketType.enabled := false;
    end;

    else
      ok := false;

  end;

  //
  if (ok) then begin
    //
    waveOut.open();
    //
    if (0 = f_decoderSourceIndex) then
      // make sure waveOut will fire waveOutAfterChunkFeed() event, so we will start feeding cycle
      waveOut.flush();
    //
  end;

  //
  a_decode_stop.enabled := not a_decode_start.enabled;
  c_comboBox_decoderSource.enabled := a_decode_start.enabled;
end;

// --  --
procedure Tc_form_main.a_decode_stopExecute(Sender: TObject);
begin
  waveOut.close();
  //
  case (f_decoderSourceIndex) of

    0: begin
      //
      case (f_decoderIndex) of

	0: begin	// Ogg/Vorbis
	  //
	  freeAndNil(f_oggInFile);
	  freeAndNil(f_vorbisDecode);
	end;

	1: begin	// BASS
	  //
	  freeAndNil(f_bassFile);
	end;

	2: begin
	  //
	  f_mpgDecoder.stop();
	  if (0 <> f_mpgFile) then
	    CloseHandle(f_mpgFile);
	end;

      end;
    end;

    1, 2: begin
      //
      f_ipComponentReady[tipeDec] := false;
      //
      f_sockClients[tipeDec].clear();
      //
      if (0 < f_sockId[tipeDec]) then
	f_socks.closeThread(f_sockId[tipeDec]);
      //
      f_sockId[tipeDec] := 0;
      f_sockConnId[tipeDec] := 0;
      //
      f_mpgDecoder.stop();
      //
      c_edit_decSrvAddr.enabled := true;
      c_edit_decSrvPort.enabled := true;
      c_comboBox_decSrvSocketType.enabled := true;
    end;

  end;
  //
  a_decode_start.enabled := true;
  a_decode_stop.enabled := not a_decode_start.enabled;
  c_comboBox_decoderSource.enabled := a_decode_start.enabled;
end;

// --  --
procedure Tc_form_main.flushOgg();
begin
  while (f_vorbisEncode.popPacket(f_op)) do begin
    //* weld the packet into the bitstream */
    f_oggOutFile.packetIn(f_op);
    f_oggOutFile.pageOut();
  end;
  //
  f_oggOutFile.flush();
end;

// --  --
procedure Tc_form_main.waveInDataAvailable(sender: unavclInOutPipe; data: Pointer; len: Cardinal);
begin
  if (nil <> f_encoder) then begin