Разработанная подсистема является неотъемлемой часть системы обработки аудиоинформации, предназначенной для обработки и кодирования звуковых сигналов. Обработка позволяет преобразовать исходный звуковой сигнал для получения необходимых характеристик его звучания перед началом кодирования. Разработанная подсистема применяется к звуковым сигналам для их подготовки к кодированию в соответствующей подсистеме. Посредством применения системы обработки аудиоинформации можно преобразовать звуковые сигналы к требуемому виду и сжать для уменьшения занимаемого ими размера.
Созданную систему следует рассматривать как исследовательскую систему, предназначенную для выявления эмпирических закономерностей в предметной области и дальнейшую разработку в направлении большей автоматизации процесса преобразования звуковых сигналов.

СПИСОК ЛИТЕРАТУРЫ

1.     Аммерал Л. Принципы программирования в машинной графике. - М.: Сол Систем, 1992.
2.     Крамер Г. Математические методы статистики. – М.: Мир, 1975.
3.     Строустрап Б. Язык программирования С++. – М.: Мир, 1994. – 278 с.
4.     Кнут Д. Искусство программирования для ЭВМ. - М.: Мир, 1976. – Т. 1-3..
5.     Корн Г., Корн Т. Справочник по математике для научных работников и инженеров. - М.: Наука, 1979. – 720с.
6.     Левкович О.А., Шелкоплясов Е.С., Шелкоплясов Т.Н. Основы компьютерной грамотности: Учебное пособие. – М.: ТетраСистемс, 2004.-528 с.
7.     ГОСТ 12.1.003-83. ССБТ. Шум, общие требования безопасности. – М.: Издательство стандартов, 1985.
8.     ГОСТ 12.1.006–84. ССБТ. Электромагнитные поля радиочастот. Допустимые уровни на рабочих местах и требования к проведению контроля. – М.: Издательство стандартов, 1985.
9.     СанПиН 2.2.2.542-96. Гигиенические требования к видео-дисплейным терминалам, персонально-вычислительным машинам и организация работ. – М.: Госкомсанэпиднадзор России, 1996.
10.Налоговый кодекс РФ. – М.: ГроссМедиа Ферлаг, 2004. – 432 с.
11.Климова Л.М. Pascal 7.0. Практическое программирование. Решение типовых задач. – М.: Кудиц-Образ, 2000.- 527с.
12.Зимина Т.Ф., Стеценко И.В. Турбо Паскаль 7.0. – Киев: БХВ, 1999 – 448с.
13.Баженова И.Ю. Delphi 5. Самоучитель программиста. – М.: Кудиц-Образ, 2000.- 336с.
14.Баас Р., Фервай М. Delphi 3.0 – Киев: БХВ, 1999 – 448с.

15.Евгений Музыченко. Часто задаваемые вопросы по цифровому представлению звуковых сигналов.

http://www.websound.ru/articles/theory/dgaudfaq.htm (22.05.2006).

16. Евгений Музыченко. Часто задаваемые вопросы электронному созданию и обработке звука

http://www.websound.ru/articles/theory/dgaudfaq.htm (22.05.2006).

17. Дмитрий Малышев. Звук: немного теории.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

18. Дмитрий Шмунк. Восприятие и сжатие звука.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

19. Александр Радзишевский. Аналоговый блюз.

http://www.websound.ru/articles/theory/sound_user.htm (22.05.2006).

20. Александр Радзишевский, Александр Чижов. Цифровой звук – обо всем по-порядку.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

21. Евгений Музыченко. Принципы цифрового звука.

http://www.websound.ru/articles/theory/digsnd.htm (22.05.2006).

22. Дмитрий Михайлов. Параметры цифрового звука.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

23. Дмитрий Михайлов. Обработка звука – фильтры.

http://www.websound.ru/articles/theory/filter.htm (22.05.2006).

24. Максим Лядов. FAQ по звуку - свежий взгляд на звуковые вопросы и ответы.

http://www.ixbt.com/multimedia/sound-faq.shtml (22.05.2006).

25. Александр Радзишевский. Пространственное звучание (3D-звук).

http://www.websound.ru/articles/technol/3dsound.htm (22.05.2006).

26. Александр Радзишевский. Способы преобразования звука, звуковые эффекты.

http://www.websound.ru/articles/processing/effects.htm (22.05.2006).

27. Сергей Котов. Эффект реверберации - теория и практика.

http://www.ixbt.com/multimedia/theory-of-reverb.shtml (22.05.2006).

28. Дмитрий Шмунк. Восприятие и сжатие звука.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

29. Дмитрий Шмунк. Восприятие и сжатие звука.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).

30.Дмитрий Шмунк. Восприятие и сжатие звука.

http://www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
31.Мандел Т. Разработка пользовательского интерфейса. ДМК Пресс, 2001.
32.Э. Гамма, Р. Хелм, Р. Джонсон, Дж. Влиссидес. Приемы объектно-ориентированного проектирования. Паттерны проектирования. – С-Пб.: Питер, 2001.
33.ГОСТ 19.505-79 ЕСПД. Руководство оператора. Требования к содержанию и оформлению. – М.: Издательство стандартов, 1979.
34.ГОСТ 19.504-79 ЕСПД. Руководство программиста. Требования к содержанию и оформлению. – М.: Издательство стандартов, 1979.
35.ГОСТ 19.701-90 ЕСПД. Схемы алгоритмов и программ. Правила выполнения. – М.: Издательство стандартов, 1991.
36.ГОСТ 12.0.002-80 ССБТ. Термины и определения. – М.: Издательство стандартов, 1980.
37.Соболева В.П. Методические указания по оформлению курсовых работ, курсовых и дипломных проектов. – Ижевск: Издательство ИМИ, 2003.
38.Почерняев С.В., Килин И.В. Методические указания по дипломному проектированию. – Ижевск: Издательство ИжГТУ, 1994.
39.Технико-экономическое обоснование дипломных проектов при разработке приборов и методов контроля качества. – Ижевск: Издательство ИжГТУ, 2001.

ПРИЛОЖЕНИЕ 1

ТЕКСТ ПРОГРАММЫ

П. 1.1. ТЕКСТ МОДУЛЯ MAIN.PAS
unit Main;
interface
uses
 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
 Dialogs, StdCtrls, Buttons, ExtCtrls, ComCtrls, Spin,
 MMSystem, ShellApi, FileUtils, AudioFormat,
 PCM_Format, MP3_Format, EM1_Format, Menus, Help, AudioForm, MP3Form, EffectsForm;
type
 TMainForm = class(TForm)
 OutDeviceComboBox: TComboBox;
 InDeviceComboBox: TComboBox;
 TrackBar: TTrackBar;
 PlayButton: TSpeedButton;
 PauseButton: TSpeedButton;
 RecordButton: TSpeedButton;
 OpenButton: TSpeedButton;
 SaveButton: TSpeedButton;
 TimePosition: TStaticText;
 PositionSpinEdit: TSpinEdit;
 OpenDialog: TOpenDialog;
 Marker1: TBitBtn;
 Marker2: TBitBtn;
 PageControl1: TPageControl;
 TabSheet1: TTabSheet;
 TabSheet2: TTabSheet;
 SetMarkerButton: TButton;
 DeleteMarkersButton: TButton;
 CopyButton: TBitBtn;
 CutButton: TBitBtn;
 ClearButton: TBitBtn;
 PasteButton: TBitBtn;
 PasteFileButton: TBitBtn;
 DeleteButton: TBitBtn;
 TabSheet3: TTabSheet;
 SetSpeedText: TStaticText;
 SetVolumeText: TStaticText;
 EffectButton: TButton;
 EffectBox: TComboBox;
 PaintBox1: TPaintBox;
 WaveOutButton: TSpeedButton;
 WaveInButton: TSpeedButton;
 PasteSilenceButton: TButton;
 CopyToFileButton: TBitBtn;
 UndoButton: TBitBtn;
 HelpButton: TBitBtn;
 SaveDialog: TSaveDialog;
 TabSheet9: TTabSheet;
 BrainWaveButton: TButton;
 BWFreqEdit1: TSpinEdit;
 StaticText15: TStaticText;
 BWFreqEdit2: TSpinEdit;
 StaticText16: TStaticText;
 SSelButton: TBitBtn;
 FSelButton: TBitBtn;
 StaticText4: TStaticText;
 UndoCheckBox: TCheckBox;
 EMailButton: TSpeedButton;
 Label1: TLabel;
 Label2: TLabel;
 Label3: TLabel;
 Label4: TLabel;
 BitBtn1: TBitBtn;
 BitBtn3: TBitBtn;
 BitBtn4: TBitBtn;
 BitBtn2: TBitBtn;
 BitBtn5: TBitBtn;
 BitBtn6: TBitBtn;
 BitBtn7: TBitBtn;
 BitBtn8: TBitBtn;
 BitBtn9: TBitBtn;
 BitBtn10: TBitBtn;
 Button1: TBitBtn;
 Button2: TBitBtn;
 Button6: TBitBtn;
 BitBtn13: TBitBtn;
 BitBtn14: TBitBtn;
 BitBtn15: TBitBtn;
 BitBtn16: TBitBtn;
 MainMenu1: TMainMenu;
 N1: TMenuItem;
 N2: TMenuItem;
 N3: TMenuItem;
 N4: TMenuItem;
 N11: TMenuItem;
 N12: TMenuItem;
 N13: TMenuItem;
 N14: TMenuItem;
 N15: TMenuItem;
 N31: TMenuItem;
 N30: TMenuItem;
 N16: TMenuItem;
 N17: TMenuItem;
 N18: TMenuItem;
 N19: TMenuItem;
 N24: TMenuItem;
 N20: TMenuItem;
 N21: TMenuItem;
 N22: TMenuItem;
 N23: TMenuItem;
 N25: TMenuItem;
 N26: TMenuItem;
 N27: TMenuItem;
 N28: TMenuItem;
 N29: TMenuItem;
 N32: TMenuItem;
 N33: TMenuItem;
 N34: TMenuItem;
 N35: TMenuItem;
 N36: TMenuItem;
 N37: TMenuItem;
 N38: TMenuItem;
 N39: TMenuItem;
 N40: TMenuItem;
 N41: TMenuItem;
 N8: TMenuItem;
 N9: TMenuItem;
 N10: TMenuItem;
 N5: TMenuItem;
 N6: TMenuItem;
 N7: TMenuItem;
 N42: TMenuItem;
 SilenceTime: TSpinEdit;
 Memo1: TMemo;
 PasteModeComboBox: TComboBox;
 PasteModeText: TStaticText;
 Left10Button: TButton;
 StaticText17: TStaticText;
 Right10Button: TButton;
 SpeedEdit: TSpinEdit;
 VolumeEdit: TSpinEdit;
 ChangeVolumeBitBtn: TBitBtn;
 ChangeSpeedButton: TBitBtn;
 SetSpeedBitBtn: TBitBtn;
 SetVolumeBitBtn: TBitBtn;
 ReverseButton: TBitBtn;
 NormalizeBitBtn: TBitBtn;
 PageControl2: TPageControl;
 TabSheet4: TTabSheet;
 Label5: TLabel;
 Label6: TLabel;
 Label7: TLabel;
 nSamplesPerSecText: TStaticText;
 nSamplesPerSecButton: TButton;
 nSamplesBox: TComboBox;
 nBitsBox: TComboBox;
 nBitsPerSampleButton: TButton;
 nBitsPerSampleText: TStaticText;
 nChannelsText: TStaticText;
 nChannelsButton: TButton;
 nChannelsBox: TComboBox;
 TabSheet5: TTabSheet;
 ConstantBitrateComboBox: TComboBox;
 StaticText1: TStaticText;
 RadioButton1: TRadioButton;
 RadioButton2: TRadioButton;
 RadioButton3: TRadioButton;
 AverageBitrateComboBox: TComboBox;
 VariableBitRateComboBox: TComboBox;
 StaticText2: TStaticText;
 StaticText3: TStaticText;
 StereoModeComboBox: TComboBox;
 TabSheet6: TTabSheet;
 PageControl3: TPageControl;
 TabSheet7: TTabSheet;
 StaticText5: TStaticText;
 nResponsesEdit: TSpinEdit;
 ResponseTimeEdit: TSpinEdit;
 ResponseVolumeEdit: TSpinEdit;
 StaticText6: TStaticText;
 StaticText7: TStaticText;
 StaticText8: TStaticText;
 StaticText9: TStaticText;
 TabSheet8: TTabSheet;
 nEchosEdit: TSpinEdit;
 DelayEdit: TSpinEdit;
 EchoVolumeEdit: TSpinEdit;
 StaticText10: TStaticText;
 StaticText11: TStaticText;
 StaticText12: TStaticText;
 StaticText13: TStaticText;
 StaticText14: TStaticText;
 N43: TMenuItem;
 MP31: TMenuItem;
 N44: TMenuItem;
 ButtonZoomIn: TBitBtn;
 ButtonZoomOut: TBitBtn;
 AudioOptionsButton: TBitBtn;
 MP3OptionsButton: TBitBtn;
 EffOptionsButton: TBitBtn;
 procedure FormCreate(Sender: TObject);
 procedure OpenButtonClick(Sender: TObject);
 procedure FormClose(Sender: TObject; var Action: TCloseAction);
 procedure PlayButtonClick(Sender: TObject);
 procedure PauseButtonClick(Sender: TObject);
 procedure RecordButtonClick(Sender: TObject);
 procedure TrackBarChange(Sender: TObject);
 procedure PositionSpinEditChange(Sender: TObject);
 procedure SaveButtonClick(Sender: TObject);
 procedure SetMarkerButtonClick(Sender: TObject);
 procedure DeleteMarkersButtonClick(Sender: TObject);
 procedure CopyButtonClick(Sender: TObject);
 procedure CutButtonClick(Sender: TObject);
 procedure ClearButtonClick(Sender: TObject);
 procedure PasteButtonClick(Sender: TObject);
 procedure ReverseButtonClick(Sender: TObject);
 procedure SetSpeedButtonClick(Sender: TObject);
 procedure ChangePropertie(Sender: TObject);
 procedure AboutButtonClick(Sender: TObject);
 procedure HomePageLinkClick(Sender: TObject);
 procedure SetVolumeButtonClick(Sender: TObject);
 procedure DeleteButtonClick(Sender: TObject);
 procedure NormalizeButtonClick(Sender: TObject);
 procedure PasteSilenceButtonClick(Sender: TObject);
 procedure SetSpeedBitBtnClick(Sender: TObject);
 procedure ChangeSpeedButtonClick(Sender: TObject);
 procedure SetVolumeBitBtnClick(Sender: TObject);
 procedure ChangeVolumeBitBtnClick(Sender: TObject);
 procedure NormalizeBitBtnClick(Sender: TObject);
 procedure EffectButtonClick(Sender: TObject);
 procedure PaintBox1Paint(Sender: TObject);
 procedure WaveOutButtonClick(Sender: TObject);
 procedure WaveInButtonClick(Sender: TObject);
 procedure CopyToFileButtonClick(Sender: TObject);
 procedure UndoButtonClick(Sender: TObject);
 procedure EMailButtonClick(Sender: TObject);
 procedure BrainWaveButtonClick(Sender: TObject);
 procedure Left10ButtonClick(Sender: TObject);
 procedure SSelButtonClick(Sender: TObject);
 procedure HelpButtonClick(Sender: TObject);
 procedure UndoCheckBoxClick(Sender: TObject);
 procedure N4Click(Sender: TObject);
 procedure N43Click(Sender: TObject);
 procedure MP31Click(Sender: TObject);
 procedure N44Click(Sender: TObject);
 procedure ButtonZoomInClick(Sender: TObject);
 procedure ButtonZoomOutClick(Sender: TObject);
 procedure AudioOptionsButtonClick(Sender: TObject);
 procedure MP3OptionsButtonClick(Sender: TObject);
 procedure EffOptionsButtonClick(Sender: TObject);
 private
 { Private declarations }
 public
 procedure SetAudioPosition;
 procedure SetMarker;
 procedure DeleteMarkers;
 procedure PaintAudioGraph;
 procedure SaveUndoInfo;
 end;
type
 TPlayThread = class(TThread)
 public
 WaveOut: HWaveOut;
 procedure Execute; override;
 end;
 TRecordThread = class(TThread)
 public
 WaveIn: HWaveIn;
 procedure Execute; override;
 end;
var
 MainForm: TMainForm;
 SamplesPerPoint: Cardinal;
 Status: String;
 AudioPosition: Cardinal;
 AudioData: TAudioData;
 AudioClipBoard: TAudioData;
 PlayThread: TPlayThread;
 RecordThread: TRecordThread;
 Selection: record
 Start: Cardinal;
 Finish: Cardinal;
 StartExists: Boolean;
 FinishExists: Boolean;
 end;
 UndoInfo: record
 Selection: record
 Start: Cardinal;
 Finish: Cardinal;
 StartExists: Boolean;
 FinishExists: Boolean;
 end;
 AudioPosition: Cardinal;
 AudioData: TAudioData;
 end;
implementation
{$R *.dfm}
procedure TMainForm.FormCreate(Sender: TObject);
var
 WaveOutCaps: TWaveOutCaps;
 WaveInCaps: TWaveInCaps;
 i: Cardinal;
begin
 SamplesPerPoint := 16;
 BorderIcons := BorderIcons - [biMaximize];
 AudioData := TAudioData.Create;
 AudioClipBoard := TAudioData.Create;
 with AudioData do
 begin
 nChannels := 2;
 nBitsPerSample := 16;
 nSamplesPerSec := 44100;
 Calculate_nBlockAlign;
 end;
 AudioPosition := 0;
 if WaveOutGetNumDevs<>0 then
 begin
 for i := 0 to WaveOutGetNumDevs-1 do
 begin
 WaveOutGetDevCaps(i, @WaveOutCaps, SizeOf(TWaveOutCaps));
 OutDeviceComboBox.Items.Add(PChar(@WaveOutCaps.szPname));
 end;
 OutDeviceComboBox.ItemIndex := 0;
 end;
 if WaveInGetNumDevs<>0 then
 begin
 for i := 0 to WaveInGetNumDevs-1 do
 begin
 WaveInGetDevCaps(i, @WaveInCaps, SizeOf(TWaveInCaps));
 InDeviceComboBox.Items.Add(PChar(@WaveInCaps.szPname));
 end;
 InDeviceComboBox.ItemIndex := 0;
 end;
 AudioData.Calculate_nBlockAlign;
 UndoInfo.AudioData := TAudioData.Create;
 Status := 'starting';
end;
procedure TMainForm.SetAudioPosition;
var
 AudioSize, Long: Cardinal;
 S, S2: String;
begin
 PaintBox1.Repaint;
 with AudioData do AudioSize := Data.Size div nBlockAlign;
 if AudioSize = 0 then Exit;
 if AudioSize<TrackBar.Width then TrackBar.Max := AudioSize else TrackBar.Max := TrackBar.Width;
 with PositionSpinEdit do
 begin
 Value := AudioPosition;
 MinValue := 0;
 MaxValue := AudioSize;
 end;
 if TrackBar.Position <> Round(AudioPosition*TrackBar.Max/AudioSize) then TrackBar.Position := Round(AudioPosition*TrackBar.Max/AudioSize);
 S2 := '';
 Long := Trunc(AudioPosition/AudioData.nSamplesPerSec);
 Str(Trunc(Long/3600), S);
 Long := Long - Trunc(Long/3600)*3600;
 S2 := S2 + S +':';
 Str(Trunc(Long/60), S);
 Long := Long - Trunc(Long/60)*60;
 if Length(S)=1 then S2 := S2 + '0';
 S2 := S2 + S +':';
 Str(Long, S);
 if Length(S)=1 then S2 := S2 + '0';
 S2 := S2 + S +' / ';
 Long := Trunc(AudioSize/AudioData.nSamplesPerSec);
 Str(Trunc(Long/3600), S);
 Long := Long - Trunc(Long/3600)*3600;
 S2 := S2 + S +':';
 Str(Trunc(Long/60), S);
 Long := Long - Trunc(Long/60)*60;
 if Length(S)=1 then S2 := S2 + '0';
 S2 := S2 + S +':';
 Str(Long, S);
 if Length(S)=1 then S2 := S2 + '0';
 S2 := S2 + S + ' ';
 if TimePosition.Caption<>S2 then TimePosition.Caption := S2;
 {PaintBox1.Repaint;}
 PaintAudioGraph;
end;
procedure TMainForm.SetMarker;
var
 AudioSize: Cardinal;
begin
 if (Status = 'starting') then Exit;
 with AudioData do AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if (AudioPosition=Start)and(StartExists) or (AudioPosition=Finish)and(FinishExists) then Exit;
 if not StartExists then
 begin
 Start := AudioPosition;
 StartExists := True;
 Marker1.Left := 8+Round(Start*(TrackBar.Max-20)/AudioSize);
 Marker1.Visible := True;
 Exit;
 end;
 if (StartExists) and (not FinishExists) then
 begin
 if AudioPosition>Start then
 Finish := AudioPosition
 else
 begin
 Finish := Start;
 Start := AudioPosition;
 end;
 FinishExists := True;
 TrackBar.SelStart := Round(Start*TrackBar.Max/AudioSize);
 TrackBar.SelEnd := Round(Finish*TrackBar.Max/AudioSize);
 Marker1.Left := 8+Round(Start*(TrackBar.Max-20)/AudioSize);
 Marker1.Visible := True;
 Marker2.Left := 8+Round(Finish*(TrackBar.Max-20)/AudioSize);
 Marker2.Visible := True;
 PaintBox1.Repaint;
 Exit;
 end;
 if (StartExists) and (FinishExists) then
 begin
 if AudioPosition<Start then
 Start := AudioPosition
 else
 if AudioPosition>Finish then
 Finish := AudioPosition;
 TrackBar.SelStart := Round(Start*TrackBar.Max/AudioSize);
 TrackBar.SelEnd := Round(Finish*TrackBar.Max/AudioSize);
 Marker1.Left := 8+Round(Start*(TrackBar.Max-20)/AudioSize);
 Marker1.Visible := True;
 Marker2.Left := 8+Round(Finish*(TrackBar.Max-20)/AudioSize);
 Marker2.Visible := True;
 PaintBox1.Repaint;
 Exit;
 end;
 end;
end;
procedure TMainForm.DeleteMarkers;
begin
 Selection.StartExists := False;
 Selection.FinishExists := False;
 Marker1.Visible := False;
 Marker2.Visible := False;
 TrackBar.SelStart := 0;
 TrackBar.SelEnd := 0;
 PaintBox1.Repaint;
end;
procedure TMainForm.OpenButtonClick(Sender: TObject);
var
 FileName, S, Ext: String;
 i: Byte;
 PCM: TPCMFile;
 MP3: TMP3File;
 EM1: TEM1File;
begin
 if (Status<>'starting')and(Status<>'waiting') then Exit;
 if OpenDialog.Execute then FileName := OpenDialog.FileName else Exit;
 Status := 'opening';
 AudioData.Data.Clear;
 if GetFileAttributes(PChar(FileName)) and FILE_ATTRIBUTE_READONLY = FILE_ATTRIBUTE_READONLY then
 SetFileAttributes(PChar(FileName), GetFileAttributes(PChar(FileName)) xor FILE_ATTRIBUTE_READONLY);
 Ext := ExtractFileExt(FileName);
 for i := 1 to Length(Ext) do Ext[i] := UpCase(Ext[i]);
 if Ext = '.WAV' then
 begin
 PCM := TPCMFile.Open(FileName);
 PCM.ReadAudioData(AudioData);
 PCM.Destroy;
 end;
 if Ext = '.MP3' then
 begin
 MP3 := TMP3File.Open(FileName);
 MP3.ReadAudioData(AudioData);
 MP3.Destroy;
 end;
 if Ext = '.EM1' then
 begin
 EM1 := TEM1File.Open(FileName);
 EM1.ReadAudioData(AudioData);
 EM1.Destroy;
 end;
 Str(AudioData.nChannels, S);
 AudioOptionsForm.nChannelsText.Caption := S + ' channels';
 Str(AudioData.nBitsPerSample, S);
 AudioOptionsForm.nBitsPerSampleText.Caption := S + ' bits';
 Str(AudioData.nSamplesPerSec, S);
 AudioOptionsForm.nSamplesPerSecText.Caption := S + ' Hz';
 AudioPosition := 0;
 AudioData.Calculate_nBlockAlign;
 SetAudioPosition;
 DeleteMarkers;
 Status := 'waiting';
end;
procedure TMainForm.PlayButtonClick(Sender: TObject);
begin
 if Status<>'waiting' then Exit;
 if OutDeviceComboBox.ItemIndex = -1 then Exit;
 if AudioPosition*AudioData.nBlockAlign >= AudioData.Data.Size then Exit;
 Status := 'playing';
 PlayThread := TPlayThread.Create(False);
end;
procedure TPlayThread.Execute;
const
 BlockSize = 1024*24;
var
 hEvent: THandle;
 WaveFormatEx: TWaveFormatEx;
 WaveHdr: array [0..1] of TWaveHdr;
 Buf: array [0..1] of array [0..BlockSize-1] of Byte;
 i: Cardinal;
begin
 with WaveFormatEx do
 begin
 wFormatTag := WAVE_FORMAT_PCM;
 nChannels := AudioData.nChannels;
 nSamplesPerSec := AudioData.nSamplesPerSec;
 wBitsPerSample := AudioData.nBitsPerSample;
 nBlockAlign := wBitsPerSample div 8 * nChannels;
 nAvgBytesPerSec := nSamplesPerSec * nBlockAlign;
 cbSize := 0;
 end;
 hEvent := CreateEvent(nil, False, False, nil);
 if WaveOutOpen(@WaveOut, MainForm.OutDeviceComboBox.ItemIndex , @WaveFormatEx, hEvent, 0, CALLBACK_EVENT) <> MMSYSERR_NOERROR then
 begin
 Status := 'waiting';
 CloseHandle(hEvent);
 Terminate;
 Exit;
 end;
 MainForm.PlayButton.Flat := True;
 for i := 0 to 1 do
 begin
 WaveHdr[i].lpData := @Buf[i];
 WaveHdr[i].dwBufferLength := BlockSize;
 AudioData.Data.Position := AudioPosition*AudioData.nBlockAlign;
 if i<>1 then
 begin
 AudioData.Data.Read(Buf[i], BlockSize);
 AudioPosition := AudioPosition + BlockSize div AudioData.nBlockAlign;
 if AudioPosition*AudioData.nBlockAlign >= AudioData.Data.Size then AudioPosition := AudioData.Data.Size div AudioData.nBlockAlign;
 end;
 WaveOutPrepareHeader(WaveOut, @WaveHdr[i], SizeOf(TWaveHdr));
 end;
 i := 0;
 while (not Terminated) and (AudioData.Data.Position<AudioData.Data.Size) do
 begin
 WaveOutWrite(WaveOut, @WaveHdr[i], SizeOf(TWaveHdr));
 WaitForSingleObject(hEvent, INFINITE);
 i := i xor 1;
 AudioData.Data.Position := AudioPosition*AudioData.nBlockAlign;
 AudioData.Data.Read(Buf[i], BlockSize);
 AudioPosition := AudioPosition + (BlockSize div AudioData.nBlockAlign);
 if AudioPosition*AudioData.nBlockAlign >= AudioData.Data.Size then AudioPosition := AudioData.Data.Size div AudioData.nBlockAlign;
 MainForm.SetAudioPosition;
 end;
 WaveOutReset(WaveOut);
 for i := 0 to 1 do WaveOutUndivpareHeader(WaveOut, @WaveHdr[i], SizeOf(WaveHdr));
 WaveOutClose(WaveOut);
 CloseHandle(hEvent);
 if not Terminated then Terminate;
 MainForm.PlayButton.Flat := False;
 Status := 'waiting';
end;
procedure TMainForm.RecordButtonClick(Sender: TObject);
begin
 if (Status<>'waiting')and(Status<>'starting') then Exit;
 if InDeviceComboBox.ItemIndex = -1 then Exit;
 Status := 'recording';
 RecordThread := TRecordThread.Create(False);
end;
procedure TRecordThread.Execute;
const
 BlockSize = 1024*24;
 BufNumber = 8;
var
 hEvent: THandle;
 WaveFormatEx: TWaveFormatEx;
 WaveHdr: array [0..BufNumber-1] of TWaveHdr;
 Buf: array [0..BufNumber-1] of array [0..BlockSize-1] of Byte;
 i: Cardinal;
begin
 with WaveFormatEx do
 begin
 wFormatTag := WAVE_FORMAT_PCM;
 nChannels := AudioData.nChannels;
 nSamplesPerSec := AudioData.nSamplesPerSec;
 wBitsPerSample := AudioData.nBitsPerSample;
 nBlockAlign := wBitsPerSample div 8 * nChannels;
 nAvgBytesPerSec := nSamplesPerSec * nBlockAlign;
 cbSize := 0;
 end;
 hEvent := CreateEvent(nil, False, False, nil);
 if WaveInOpen(@WaveIn, MainForm.InDeviceComboBox.ItemIndex , @WaveFormatEx, hEvent, 0, CALLBACK_EVENT) <> MMSYSERR_NOERROR then
 begin
 Status := 'waiting';
 CloseHandle(hEvent);
 Terminate;
 Exit;
 end;
 MainForm.RecordButton.Flat := True;
 for i := 0 to BufNumber-1 do
 begin
 WaveHdr[i].lpData := @Buf[i];
 WaveHdr[i].dwBufferLength := BlockSize;
 WaveInPrepareHeader(WaveIn, @WaveHdr[i], SizeOf(TWaveHdr));
 end;
 WaveInStart(WaveIn);
 WaitForSingleObject(hEvent, INFINITE);
 for i := 0 to BufNumber-1 do
 WaveInAddBuffer(WaveIn, @WaveHdr[i], SizeOf(TWaveHdr));
 i := BufNumber-1;
 while not Terminated do
 begin
 if i = BufNumber-1 then i := 0 else Inc(i);
 if (WaveHdr[i].dwFlags and WHDR_DONE) <> WHDR_DONE then
 WaitForSingleObject(hEvent, INFINITE);
 AudioData.Data.Position := AudioPosition*AudioData.nBlockAlign;
 AudioData.Data.Write(Buf[i], WaveHdr[i].dwBytesRecorded);
 AudioPosition := AudioPosition + (WaveHdr[i].dwBytesRecorded div AudioData.nBlockAlign);
 WaveInAddBuffer(WaveIn, @WaveHdr[i], SizeOf(TWaveHdr));
 MainForm.SetAudioPosition;
 end;
 WaveInReset(WaveIn);
 for i := 0 to BufNumber-1 do
 WaveInUndivpareHeader(WaveIn, @WaveHdr[i], SizeOf(WaveHdr));
 WaveInClose(WaveIn);
 CloseHandle(hEvent);
 if not Terminated then Terminate;
 with MainForm.PositionSpinEdit do
 begin
 Value := AudioPosition;
 MinValue := 0;
 MaxValue := AudioData.Data.Size div AudioData.nBlockAlign;;
 end;
 MainForm.RecordButton.Flat := False;
 Status := 'waiting';
end;
procedure TMainForm.PauseButtonClick(Sender: TObject);
begin
 if Status = 'playing' then PlayThread.Terminate;
 if Status = 'recording' then RecordThread.Terminate;
end;
procedure TMainForm.TrackBarChange(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 if TrackBar.Position <> Round(AudioPosition*TrackBar.Max/AudioSize) then
 begin
 AudioPosition := Round(TrackBar.Position/TrackBar.Max*AudioSize);
 SetAudioPosition;
 end;
end;
procedure TMainForm.PositionSpinEditChange(Sender: TObject);
begin
 if Status<>'waiting' then Exit;
 AudioPosition := PositionSpinEdit.Value;
 SetAudioPosition;
end;
procedure TMainForm.SaveButtonClick(Sender: TObject);
var
 FileName, Ext, EncMode, StereoMode, BitRate: String;
 i: Byte;
 Code: Integer;
 PCM: TPCMFile;
 MP3: TMP3File;
 EM1: TEM1File;
begin
 if Status<>'waiting' then Exit;
 if SaveDialog.Execute then
 FileName := SaveDialog.FileName else Exit;
 Ext := ExtractFileExt(FileName);
 for i := 1 to Length(Ext) do Ext[i] := UpCase(Ext[i]);
 if Ext = '.WAV' then
 begin
 PCM := TPCMFile.Create(FileName, AudioData);
 PCM.Destroy;
 end;
 if Ext = '.MP3' then
 begin
 if RadioButton1.Checked then
 begin
 BitRate := MP3OptionsForm.ConstantBitRateComboBox.Text;
 EncMode := '-b';
 end;
 if RadioButton2.Checked then
 begin
 BitRate := MP3OptionsForm.AverageBitRateComboBox.Text;
 EncMode := '--abr';
 end;
 if RadioButton3.Checked then
 begin
 Str(MP3OptionsForm.VariableBitrateComboBox.ItemIndex, BitRate);
 EncMode := '-V';
 end;
 case MP3OptionsForm.StereoModeComboBox.ItemIndex of
 0: StereoMode := 's';
 1: StereoMode := 'j';
 2: StereoMode := 'f';
 3: StereoMode := 'd';
 4: StereoMode := 'm';
 end;
 MP3 := TMP3File.Create(FileName, AudioData, BitRate, EncMode, StereoMode);
 MP3.Destroy;
 end;
 if Ext = '.EM1' then
 begin
 EM1 := TEM1File.Create(FileName, AudioData);
 EM1.Destroy;
 end;
end;
procedure TMainForm.SetMarkerButtonClick(Sender: TObject);
begin
 SetMarker;
end;
procedure TMainForm.DeleteMarkersButtonClick(Sender: TObject);
begin
 DeleteMarkers;
end;
procedure TMainForm.CopyButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
 S: String;
begin
 if Status<>'waiting' then Exit;
 Status := 'editing';
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 CopyAudio(AudioData, AudioClipBoard, Start, Finish);
 end;
 Str(AudioClipBoard.Data.Size div AudioClipBoard.nBlockAlign div AudioClipBoard.nSamplesPerSec, S);
 Memo1.Text := 'В буффере ' + S + ' сек.';
 Status := 'waiting';
end;
procedure TMainForm.DeleteButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'editing';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 DeleteAudio(AudioData, Start, Finish);
 DeleteMarkers;
 AudioPosition := Start;
 SetAudioPosition;
 end;
 Status := 'waiting';
end;
procedure TMainForm.CutButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
 S: String;
begin
 if Status<>'waiting' then Exit;
 Status := 'editing';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 CopyAudio(AudioData, AudioClipBoard, Start, Finish);
 DeleteAudio(AudioData, Start, Finish);
 DeleteMarkers;
 AudioPosition := Start;
 SetAudioPosition;
 end;
 Str(AudioClipBoard.Data.Size div AudioClipBoard.nBlockAlign div AudioClipBoard.nSamplesPerSec, S);
 Memo1.Text := 'В буффере ' + S + ' сек.';
 Status := 'waiting';
end;
procedure TMainForm.ClearButtonClick(Sender: TObject);
var
 AudioSize, i: Cardinal;
 Buf: Byte;
begin
 if Status<>'waiting' then Exit;
 Status := 'editing';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 Buf := 0;
 AudioData.Data.Position := Start*AudioData.nBlockAlign;
 for i := Start*AudioData.nBlockAlign to Finish*AudioData.nBlockAlign-1 do
 AudioData.Data.Write(Buf, 1);
 end;
 Status := 'waiting';
 PaintAudioGraph;
end;
procedure TMainForm.PasteButtonClick(Sender: TObject);
var
 MP3: TMP3File;
 PCM: TPCMFile;
 EM1: TEM1File;
 i: Byte;
 FileName, S, Ext: String;
 TempAudio: TAudioData;
begin
 if (Status<>'waiting')and(Status<>'starting') then Exit;
 if Sender = PasteFileButton then
 begin
 if OpenDialog.Execute then FileName := OpenDialog.FileName else Exit;
 Status := 'opening';
 Ext := ExtractFileExt(FileName);
 if GetFileAttributes(PChar(FileName)) and FILE_ATTRIBUTE_READONLY = FILE_ATTRIBUTE_READONLY then
 SetFileAttributes(PChar(FileName), GetFileAttributes(PChar(FileName)) xor FILE_ATTRIBUTE_READONLY);
 TempAudio := TAudioData.Create;
 for i := 1 to Length(Ext) do Ext[i] := UpCase(Ext[i]);
 if Ext = '.WAV' then
 begin
 PCM := TPCMFile.Open(FileName);
 PCM.ReadAudioData(TempAudio);
 PCM.Destroy;
 end;
 if Ext = '.MP3' then
 begin
 MP3 := TMP3File.Open(FileName);
 MP3.ReadAudioData(TempAudio);
 MP3.Destroy;
 end;
 if Ext = '.EM1' then
 begin
 EM1 := TEM1File.Open(FileName);
 EM1.ReadAudioData(TempAudio);
 EM1.Destroy;
 end;
 SetnSamplesPerSec(TempAudio, AudioData.nSamplesPerSec);
 SetnBitsPerSample(TempAudio, AudioData.nBitsPerSample);
 SetnChannels(TempAudio, AudioData.nChannels);
 end
 else
 begin
 SetnSamplesPerSec(AudioClipBoard, AudioData.nSamplesPerSec);
 SetnBitsPerSample(AudioClipBoard, AudioData.nBitsPerSample);
 SetnChannels(AudioClipBoard, AudioData.nChannels);
 end;
 Status := 'editing';
 SaveUndoInfo;
 if Sender <> PasteFileButton then
 Case PasteModeComboBox.ItemIndex of
 0: InsertAudio(AudioClipBoard, AudioData, AudioPosition);
 1: OverWriteAudio(AudioClipBoard, AudioData, AudioPosition);
 2: MixAudio(AudioClipBoard, AudioData, AudioPosition);
 end
 else
 Case PasteModeComboBox.ItemIndex of
 0: InsertAudio(TempAudio, AudioData, AudioPosition);
 1: OverWriteAudio(TempAudio, AudioData, AudioPosition);
 2: MixAudio(TempAudio, AudioData, AudioPosition);
 end;
 DeleteMarkers;
 SetAudioPosition;
 SetMarker;
 if Sender <> PasteFileButton then
 AudioPosition := AudioPosition + AudioClipBoard.Data.Size div AudioData.nBlockAlign - 1
 else
 begin
 AudioPosition := AudioPosition + TempAudio.Data.Size div AudioData.nBlockAlign - 1;
 TempAudio.Destroy;
 end;
 SetAudioPosition;
 SetMarker;
 Status := 'waiting';
end;
procedure TMainForm.PasteSilenceButtonClick(Sender: TObject);
var
 i: Cardinal;
 b: Byte;
 TempAudio: TAudioData;
begin
 if (Status<>'waiting')and(Status<>'starting') then Exit;
 Status := 'editing';
 SaveUndoInfo;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.Calculate_nBlockAlign;
 b := 0;
 for i := 1 to TempAudio.nSamplesPerSec*SilenceTime.Value*TempAudio.nBlockAlign do
 TempAudio.Data.Write(b, 1);
 InsertAudio(TempAudio, AudioData, AudioPosition);
 DeleteMarkers;
 SetAudioPosition;
 SetMarker;
 AudioPosition := AudioPosition + TempAudio.Data.Size div AudioData.nBlockAlign - 1;
 SetAudioPosition;
 SetMarker;
 TempAudio.Destroy;
 Status := 'waiting';
end;
procedure TMainForm.ReverseButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 ReverseAudio(AudioData, Start, Finish-Start+1);
 end;
 Status := 'waiting';
end;
procedure TMainForm.NormalizeButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 Normalize(AudioData, Start, Finish-Start+1);
 end;
 Status := 'waiting';
 PaintBox1.Repaint;
end;
procedure TMainForm.SetSpeedButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 SetSpeedOfAudio(AudioData, Start, Finish-Start+1, SpeedEdit.Value/100);
 DeleteMarkers;
 AudioPosition := Start;
 SetMarker;
 AudioPosition := Trunc(Start+(Finish-Start)*100/SpeedEdit.Value);
 SetMarker;
 AudioPosition := Start;
 SetAudioPosition;
 end;
 Status := 'waiting';
end;
procedure TMainForm.ChangePropertie(Sender: TObject);
var
 S: String;
 Value, Code: Cardinal;
begin
 if (Status<>'waiting')and(Status<>'starting') then Exit;
 Status := 'editing';
 if Sender = AudioOptionsForm.nSamplesPerSecButton then
 begin
 Val(AudioOptionsForm.nSamplesBox.Text, Value, Code);
 SetnSamplesPerSec(AudioData, Value);
 end;
 if Sender = AudioOptionsForm.nBitsPerSampleButton then
 begin
 Val(AudioOptionsForm.nBitsBox.Text, Value, Code);
 SetnBitsPerSample(AudioData, Value);
 end;
 if Sender = AudioOptionsForm.nChannelsButton then
 begin
 SetnChannels(AudioData, AudioOptionsForm.nChannelsBox.ItemIndex+1);
 end;
 AudioData.Calculate_nBlockAlign;
 DeleteMarkers;
 AudioPosition := 0;
 SetAudioPosition;
 Str(AudioData.nChannels, S);
 AudioOptionsForm.nChannelsText.Caption := S + ' channels';
 Str(AudioData.nBitsPerSample, S);
 AudioOptionsForm.nBitsPerSampleText.Caption := S + ' bits';
 Str(AudioData.nSamplesPerSec, S);
 AudioOptionsForm.nSamplesPerSecText.Caption := S + ' Hz';
 Status := 'waiting';
end;
procedure TMainForm.SetVolumeButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 SetVolumeOfAudio(AudioData, Start, Finish-Start+1, VolumeEdit.Value/100);
 end;
 Status := 'waiting';
end;
procedure TMainForm.AboutButtonClick(Sender: TObject);
begin
 MessageBox(MainForm.Handle, 'AudioEditor v02.2006'#13#13'Выполнил Суханов М.А.'#13#13'ИжГТУ, 2006'#13#13'[email protected]', 'О программе', MB_OK);
end;
procedure TMainForm.HomePageLinkClick(Sender: TObject);
begin
 ShellExecute(Handle, 'open', PChar('http://Andrei512.narod.ru'), '', '', SW_Show);
end;
procedure TMainForm.FormClose(Sender: TObject; var Action: TCloseAction);
begin
 AudioData.Destroy;
 AudioClipBoard.Destroy;
 UndoInfo.AudioData.Destroy;
end;
procedure TMainForm.SetSpeedBitBtnClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 SetSpeedOfAudio(AudioData, Start, Finish-Start+1, SpeedEdit.Value/100);
 DeleteMarkers;
 AudioPosition := Start;
 SetMarker;
 AudioPosition := Trunc(Start+(Finish-Start)*100/SpeedEdit.Value);
 SetMarker;
 AudioPosition := Start;
 SetAudioPosition;
 end;
 Status := 'waiting';
end;
procedure TMainForm.ChangeSpeedButtonClick(Sender: TObject);
var
 AudioSize, NewCount: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 NewCount := ChangeSpeedOfAudio(AudioData, Start, Finish-Start+1, SpeedEdit.Value/100);
 DeleteMarkers;
 AudioPosition := Start;
 SetMarker;
 AudioPosition := Start+NewCount;
 SetMarker;
 AudioPosition := Start;
 SetAudioPosition;
 end;
 Status := 'waiting';
end;
procedure TMainForm.SetVolumeBitBtnClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 SetVolumeOfAudio(AudioData, Start, Finish-Start+1, VolumeEdit.Value/100);
 end;
 Status := 'waiting';
 PaintBox1.Repaint;
end;
procedure TMainForm.ChangeVolumeBitBtnClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 ChangeVolumeOfAudio(AudioData, Start, Finish-Start+1, VolumeEdit.Value/100);
 end;
 Status := 'waiting';
 PaintBox1.Repaint;
end;
procedure TMainForm.NormalizeBitBtnClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 Normalize(AudioData, Start, Finish-Start+1);
 end;
 Status := 'waiting';
end;
procedure TMainForm.EffectButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 if Sender = BitBtn13 then Echo(AudioData, Start, Finish-Start+1, EffOptionsForm.nResponsesEdit.Value, EffOptionsForm.ResponseTimeEdit.Value, EffOptionsForm.ResponseVolumeEdit.Value/100);
 if Sender = BitBtn14 then Reverberation(AudioData, Start, Finish-Start+1, EffOptionsForm.nEchosEdit.Value, EffOptionsForm.DelayEdit.Value, EffOptionsForm.EchoVolumeEdit.Value/100);
 if Sender = BitBtn15 then ChangeVolumeOfAudio(AudioData, Start, Finish-Start+1, 0);
 if Sender = BitBtn16 then ReChangeVolumeOfAudio(AudioData, Start, Finish-Start+1, 1);
 {case EffectBox.ItemIndex of
 0: ChangeVolumeOfAudio(AudioData, Start, Finish-Start+1, 0);
 1: ReChangeVolumeOfAudio(AudioData, Start, Finish-Start+1, 1);
 2: Echo(AudioData, Start, Finish-Start+1, nResponsesEdit.Value, ResponseTimeEdit.Value, ResponseVolumeEdit.Value/100);
 3: Reverberation(AudioData, Start, Finish-Start+1, nEchosEdit.Value, DelayEdit.Value, EchoVolumeEdit.Value/100);
 end;}
 end;
 Status := 'waiting';
 PaintBox1.Repaint;
end;
procedure TMainForm.PaintAudioGraph;
var
 PaintPos, MaxPaintPos: Cardinal;
 AudioPos, {SamplesPerPoint,} LeftSamples, MaxAmplitude: Cardinal;
 numChannels, Channel, i: Word;
 Smp, Smp1: Integer;
begin
 with PaintBox1.Canvas do
 begin
 Pen.Color := clBlack;
 MoveTo(Round(PaintBox1.Width/2),0);
 LineTo(Round(PaintBox1.Width/2), Round(PaintBox1.Height));
 MoveTo(0, Round(PaintBox1.Height/2));
 LineTo(PaintBox1.Width, Round(PaintBox1.Height/2));
 Pen.Color := clGreen;
 end;
 MaxPaintPos := PaintBox1.Width;
 if AudioPosition-PaintBox1.Width*SamplesPerPoint >= 0 then
 begin
 AudioPos := AudioPosition-PaintBox1.Width*SamplesPerPoint;
 PaintPos := 0;
 end
 else
 begin
 AudioPos := 0;
 PaintPos := PaintBox1.Width - Trunc(AudioPosition/SamplesPerPoint);
 end;
 numChannels := AudioData.nChannels;
 MaxAmplitude := 1;
 for i := 1 to AudioData.nBitsPerSample do
 MaxAmplitude := MaxAmplitude*2;
 Smp := 0;
 for Channel := 0 to numChannels-1 do
 begin
 AudioData.ReadSample(AudioPos, Channel, Smp1);
 Smp := Smp + Smp1;
 end;
 Smp := Round(Smp/numChannels);
 PaintBox1.Canvas.MoveTo(PaintPos-Round(PaintBox1.Width/2), Round(PaintBox1.Height/2-Smp/MaxAmplitude*PaintBox1.Height));
 LeftSamples := SamplesPerPoint;
 while PaintPos<=(MaxPaintPos+Round(PaintBox1.Width/2)) do
 begin
 Smp := 0;
 for Channel := 0 to numChannels-1 do
 begin
 AudioData.ReadSample(AudioPos, Channel, Smp1);
 Smp := Smp + Smp1;
 end;
 if (Selection.StartExists)and(Selection.FinishExists)and
 (AudioPos>Selection.Start)and(AudioPos<Selection.Finish)
 then PaintBox1.Canvas.Pen.Color := clRed
 else PaintBox1.Canvas.Pen.Color := clGreen;
 Smp := Round(Smp/numChannels);
 PaintBox1.Canvas.LineTo(PaintPos-Round(PaintBox1.Width/2), Round(PaintBox1.Height/2-Smp/MaxAmplitude*PaintBox1.Height));
 Inc(AudioPos);
 Dec(LeftSamples);
 if LeftSamples = 0 then
 begin
 Inc(PaintPos);
 LeftSamples := SamplesPerPoint;
 end;
 end;
end;
procedure TMainForm.PaintBox1Paint(Sender: TObject);
begin
 PaintAudioGraph;
end;
procedure TMainForm.WaveOutButtonClick(Sender: TObject);
begin
 ShellExecute(Handle, 'open', PChar('sndvol32.exe'), '', '', SW_Show);
end;
procedure TMainForm.WaveInButtonClick(Sender: TObject);
begin
 ShellExecute(Handle, 'open', PChar('sndvol32.exe'), PChar('/r'), '', SW_Show);
end;
procedure TMainForm.CopyToFileButtonClick(Sender: TObject);
var
 FileName, Ext, EncMode, StereoMode, BitRate: String;
 i: Byte;
 TempAudio: TAudioData;
 Code: Integer;
 PCM: TPCMFile;
 MP3: TMP3File;
 EM1: TEM1File;
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 if SaveDialog.Execute then
 FileName := SaveDialog.FileName else Exit;
 Ext := ExtractFileExt(FileName);
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 TempAudio := TAudioData.Create;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 CopyAudio(AudioData, TempAudio, Start, Finish);
 end;
 for i := 1 to Length(Ext) do Ext[i] := UpCase(Ext[i]);
 if Ext = '.WAV' then
 begin
 PCM := TPCMFile.Create(FileName, TempAudio);
 PCM.Destroy;
 end;
 if Ext = '.MP3' then
 begin
 if RadioButton1.Checked then
 begin
 BitRate := MP3OptionsForm.ConstantBitRateComboBox.Text;
 EncMode := '-b';
 end;
 if RadioButton2.Checked then
 begin
 BitRate := MP3OptionsForm.AverageBitRateComboBox.Text;
 EncMode := '--abr';
 end;
 if RadioButton3.Checked then
 begin
 Str(MP3OptionsForm.VariableBitrateComboBox.ItemIndex, BitRate);
 EncMode := '-V';
 end;
 case MP3OptionsForm.StereoModeComboBox.ItemIndex of
 0: StereoMode := 's';
 1: StereoMode := 'j';
 2: StereoMode := 'f';
 3: StereoMode := 'd';
 4: StereoMode := 'm';
 end;
 MP3 := TMP3File.Create(FileName, TempAudio, BitRate, EncMode, StereoMode);
 MP3.Destroy;
 end;
 if Ext = '.EM1' then
 begin
 EM1 := TEM1File.Create(FileName, TempAudio);
 EM1.Destroy;
 end;
 TempAudio.Destroy;
end;
procedure TMainForm.SaveUndoInfo;
begin
 if not UndoCheckBox.Checked then Exit;
 UndoInfo.AudioPosition := AudioPosition;
 UndoInfo.Selection.Start := Selection.Start;
 UndoInfo.Selection.Finish := Selection.Finish;
 UndoInfo.Selection.StartExists := Selection.StartExists;
 UndoInfo.Selection.FinishExists := Selection.FinishExists;
 UndoInfo.AudioData.Data.Clear;
 CopyAudio(AudioData, UndoInfo.AudioData, 0, AudioData.Data.Size div AudioData.nBlockAlign - 1);
end;
procedure TMainForm.UndoButtonClick(Sender: TObject);
begin
 if Status<>'waiting' then Exit;
 if UndoInfo.AudioData.Data.Size = 0 then Exit;
 Status := 'undo';
 DeleteMarkers;
 AudioData.Data.Clear;
 CopyAudio(UndoInfo.AudioData, AudioData, 0, UndoInfo.AudioData.Data.Size div UndoInfo.AudioData.nBlockAlign - 1);
 if UndoInfo.Selection.StartExists then
 begin
 AudioPosition := UndoInfo.Selection.Start;
 SetMarker;
 end;
 if UndoInfo.Selection.FinishExists then
 begin
 AudioPosition := UndoInfo.Selection.Finish;
 SetMarker;
 end;
 AudioPosition := UndoInfo.AudioPosition;
 SetAudioPosition;
 UndoInfo.AudioData.Data.Clear;
 Status := 'waiting';
end;
procedure TMainForm.EMailButtonClick(Sender: TObject);
begin
 ShellExecute(Handle, 'open', PChar('mailto:[email protected]'), PChar(''), '', SW_Show);
end;
procedure TMainForm.BrainWaveButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 Status := 'deformation';
 SaveUndoInfo;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 with Selection do
 begin
 if not StartExists or not FinishExists then
 begin
 DeleteMarkers;
 Start := 0;
 Finish := AudioSize-1;
 end;
 AddBrainWave(AudioData, Start, Finish-Start+1, BWFreqEdit1.Value, BWFreqEdit2.Value);
 end;
 Status := 'waiting';
end;
procedure TMainForm.Left10ButtonClick(Sender: TObject);
var
 AudioSize, Smp10ms: Cardinal;
begin
 if Status<>'waiting' then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 Smp10ms := Round(AudioData.nSamplesPerSec/100);
 if Sender = Left10Button then
 if AudioPosition < Smp10ms then AudioPosition := 0 else AudioPosition := AudioPosition - Smp10ms
 else
 if AudioPosition + Smp10ms >= AudioSize then AudioPosition := AudioSize - 1 else AudioPosition := AudioPosition + Smp10ms;
 SetAudioPosition;
end;
procedure TMainForm.SSelButtonClick(Sender: TObject);
var
 AudioSize: Cardinal;
begin
 if Status<>'waiting' then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 if Sender = {SSelButton}BitBtn3 then
 if Selection.StartExists then AudioPosition := Selection.Start else AudioPosition := 0
 else
 if Selection.FinishExists then AudioPosition := Selection.Finish else AudioPosition := AudioSize - 1;
 SetAudioPosition;
end;
procedure TMainForm.HelpButtonClick(Sender: TObject);
begin
 HelpForm.Visible := True;
 HelpForm.Show;
end;
procedure TMainForm.UndoCheckBoxClick(Sender: TObject);
begin
 if UndoCheckBox.Checked then
 UndoButton.Enabled := True
 else
 begin
 UndoButton.Enabled := False;
 UndoInfo.AudioData.Data.Clear;
 end;
end;
procedure TMainForm.N4Click(Sender: TObject);
begin
 MainForm.Close;
end;
procedure TMainForm.N43Click(Sender: TObject);
begin
 AudioOptionsForm.Visible := True;
 AudioOptionsForm.Show;
end;
procedure TMainForm.MP31Click(Sender: TObject);
begin
 MP3OptionsForm.Visible := True;
 MP3OptionsForm.Show;
end;
procedure TMainForm.N44Click(Sender: TObject);
begin
 EffOptionsForm.Visible := True;
 EffOptionsForm.Show;
end;
procedure TMainForm.ButtonZoomInClick(Sender: TObject);
begin
 SamplesPerPoint := SamplesPerPoint div 2;
 if (SamplesPerPoint<1) then SamplesPerPoint:=1;
 PaintBox1.Repaint;
end;
procedure TMainForm.ButtonZoomOutClick(Sender: TObject);
begin
 SamplesPerPoint := SamplesPerPoint * 2;
 PaintBox1.Repaint;
end;
procedure TMainForm.AudioOptionsButtonClick(Sender: TObject);
begin
 AudioOptionsForm.Visible := True;
 AudioOptionsForm.Show;
end;
procedure TMainForm.MP3OptionsButtonClick(Sender: TObject);
begin
 MP3OptionsForm.Visible := True;
 MP3OptionsForm.Show;
end;
procedure TMainForm.EffOptionsButtonClick(Sender: TObject);
begin
 EffOptionsForm.Visible := True;
 EffOptionsForm.Show;
end;
end.
П. 1.2. ТЕКСТ МОДУЛЯ PCM_FORMAT.PAS
unit PCM_Format;
interface
uses
 SysUtils, AudioFormat;
type
 TPCMFile = class(TAudioFile)
 public
 RIFFLabel: String;
 RIFFSize: LongWord;
 fccType: String;
 fmt_Label: String;
 fmtSize: LongWord;
 formatTag: Word;
 nChannels: Word;
 nSamplesPerSec: LongWord;
 nAvgBytesPerSec: LongWord;
 nBlockAlign: Word;
 nBitsPerSample: Word;
 DataID: String;
 AdvDataBegin: LongWord; //*
 DataSize: LongWord;
 DataLabel: String;
 SndDataBegin: LongWord; //*
 nDataBytes: LongWord;
 constructor Open(FileName: string);
 function ReadSample(Number, Channel: LongInt): Integer;
 procedure WriteSample(Number, Channel: LongInt; Value: Integer);
 procedure ReadAudioData(var AudioData: TAudioData);
 constructor Create(FileName: string; var AudioData: TAudioData);
 private
 { Private declarations }
 end;
implementation
constructor TPCMFile.Open(FileName: String);
begin
 inherited Open(FileName);
 ReadString(RIFFLabel, 4);
 Read(RIFFSize, 4);
 ReadString(fccType, 4);
 ReadString(fmt_Label, 4);
 Read(fmtSize, 4);
 Read(formatTag, 2);
 Read(nChannels, 2);
 Read(nSamplesPerSec, 4);
 Read(nAvgBytesPerSec, 4);
 Read(nBlockAlign, 2);
 Read(nBitsPerSample, 2);
 Position := $14 + fmtSize;
 ReadString(DataLabel, 4);
 if DataLabel <> 'data' then
 begin
 DataId := DataLabel;
 Read(DataSize, 4);
 AdvDataBegin := Position;
 Position := Position + DataSize;
 ReadString(DataLabel, 4);
 end
 else
 begin
 DataID := '';
 DataSize := 0;
 end;
 Read(nDataBytes, 4);
 SndDataBegin := Position;
end;
function TPCMFile.ReadSample(Number, Channel: LongInt): Integer;
var
 i: Byte;
 Value, Mult: LongWord;
begin
 Position := SndDataBegin + Number*nBlockAlign + Channel*Trunc(nBlockAlign/nChannels);
 Value := 0;
 Read(Value, Trunc(nBlockAlign/nChannels));
 Mult := 1;
 for i := 0 to Trunc(nBlockAlign/nChannels)-1 do Mult := Mult*256;
 if nBitsPerSample>8 then
 if Value >= Mult/2 then ReadSample := Value - Mult else ReadSample := Value
 else
 ReadSample := Value-128;
end;
procedure TPCMFile.WriteSample(Number, Channel: LongInt; Value: Integer);
begin
 Position := SndDataBegin + Number*nBlockAlign + Channel*Trunc(nBlockAlign/nChannels);
 if nBitsPerSample<=8 then Value := Value+128;
 Write(Value, Trunc(nBlockAlign/nChannels));
end;
procedure TPCMFile.ReadAudioData(var AudioData: TAudioData);
const
 MaxBufSize = 65536;
var
 i: Cardinal;
 BufSize: Cardinal;
 Buf: array [0..MaxBufSize] of Byte;
begin
 AudioData.Data.Clear;
 Position := SndDataBegin;
 while Position<Size do
 begin
 if Size-Position>=MaxBufSize then BufSize := MaxBufSize else BufSize := Size-Position;
 Read(Buf, BufSize);
 AudioData.Data.Write(Buf, BufSize);
 end;
 AudioData.nChannels := nChannels;
 AudioData.nSamplesPerSec := nSamplesPerSec;
 AudioData.nBitsPerSample := nBitsPerSample;
 AudioData.Calculate_nBlockAlign;
end;
constructor TPCMFile.Create(FileName: string; var AudioData: TAudioData);
const
 MaxBufSize = 65536;
var
 i: Cardinal;
 BufSize: Cardinal;
 Buf: array [0..MaxBufSize] of Byte;
begin
 inherited Create(FileName);
 RIFFLabel := 'RIFF';
 RIFFSize := AudioData.Data.Size+4*3+2*2+4*2+2*2+4*2;
 fccType := 'WAVE';
 fmt_Label := 'fmt ';
 fmtSize := 16;
 formatTag := 1; //???
 nChannels := AudioData.nChannels;
 nSamplesPerSec := AudioData.nSamplesPerSec;
 nBlockAlign := AudioData.nBitsPerSample div 8;
 if AudioData.nBitsPerSample mod 8 <> 0 then Inc(nBlockAlign);
 nBlockAlign := nBlockAlign*nChannels;
 nAvgBytesPerSec := nSamplesPerSec*nBlockAlign;
 nBitsPerSample := AudioData.nBitsPerSample;
 DataLabel := 'data';
 nDataBytes := AudioData.Data.Size;
 WriteString(RIFFLabel, 4);
 Write(RIFFSize, 4);
 WriteString(fccType, 4);
 WriteString(fmt_Label, 4);
 Write(fmtSize, 4);
 Write(formatTag, 2);
 Write(nChannels, 2);
 Write(nSamplesPerSec, 4);
 Write(nAvgBytesPerSec, 4);
 Write(nBlockAlign, 2);
 Write(nBitsPerSample, 2);
 WriteString(DataLabel, 4);
 Write(nDataBytes, 4);
 DataID := '';
 DataSize := 0;
 SndDataBegin := Position;
 AudioData.Data.Position := 0;
 while AudioData.Data.Position < AudioData.Data.Size do
 begin
 with AudioData.Data do
 begin
 if Size-Position>=MaxBufSize then BufSize := MaxBufSize else BufSize := Size-Position;
 Read(Buf, BufSize);
 end;
 Write(Buf, BufSize);
 end;
end;
end.
П. 1.3. ТЕКСТ МОДУЛЯ MP3_FORMAT.PAS
unit MP3_Format;
interface
uses
 SysUtils, ShellApi, Windows, Classes, AudioFormat, PCM_Format;
type
 TMP3File = class(TAudioFile)
 public
 constructor Open(FileName: string);
 constructor Create(FileName: string; var AudioData: TAudioData; BitRate, EncMode, StereoMode: String);
 procedure ReadAudioData(var AudioData: TAudioData);
 private
 Name: String;
 end;
implementation
{$R Lame.res}
var
 Res: TResourceStream;
 TempDir: String;
 LameFile: String;
 LameParameters: String;
constructor TMP3File.Open(FileName: string);
begin
 inherited Open(FileName);
 Name := FileName;
end;
constructor TMP3File.Create(FileName: string; var AudioData: TAudioData; BitRate, EncMode, StereoMode: String);
var
 TempWaveFile: String;
 PCM: TPCMFile;
 StartupInfo: TStartupInfo;
 ProcessInformation: TProcessInformation;
begin
 TempWaveFile := TempDir+'TempWave.wav';
 PCM := TPCMFile.Create(TempWaveFile, AudioData);
 PCM.Destroy;
 LameParameters := LameFile+' -m '+StereoMode+' '+EncMode+' '+BitRate+' "'+TempWaveFile+'" "'+FileName+'"';
 FillChar(StartupInfo, SizeOf(StartupInfo), 0 );
 StartupInfo.cb := SizeOf(StartupInfo);
 StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
 StartupInfo.wShowWindow := SW_HIDE;
 CreateProcess(nil, PChar(LameParameters), nil, nil, False, CREATE_DEFAULT_ERROR_MODE+HIGH_PRIORITY_CLASS, nil, nil, StartupInfo, ProcessInformation);
 WaitForSingleObject(ProcessInformation.hProcess, infinite);
 DeleteFile(PChar(TempWaveFile));
 inherited Open(FileName);
 Name := FileName;
end;
procedure TMP3File.ReadAudioData(var AudioData: TAudioData);
var
 TempWaveFile: String;
 PCM: TPCMFile;
 Result: Word;
 StartupInfo: TStartupInfo;
 ProcessInformation: TProcessInformation;
begin
 TempWaveFile := TempDir+'TempWave.wav';
 LameParameters := LameFile+' --decode '+'"'+Name+'" "'+TempWaveFile+'"';
 FillChar(StartupInfo, SizeOf(StartupInfo), 0 );
 StartupInfo.cb := SizeOf(StartupInfo);
 StartupInfo.dwFlags := STARTF_USESHOWWINDOW;
 StartupInfo.wShowWindow := SW_HIDE;
 CreateProcess(nil, PChar(LameParameters), nil, nil, False, CREATE_DEFAULT_ERROR_MODE+HIGH_PRIORITY_CLASS, nil, nil, StartupInfo, ProcessInformation);
 WaitForSingleObject(ProcessInformation.hProcess, infinite);
 PCM := TPCMFile.Open(TempWaveFile);
 PCM.ReadAudioData(AudioData);
 PCM.Destroy;
 DeleteFile(PChar(TempWaveFile));
end;
initialization
 TempDir := GetEnvironmentVariable('TEMP')+'\';
 Res := TResourceStream.Create(Hinstance, 'Lame', 'ExeFile');
 LameFile := TempDir+'Lame.exe';
 Res.SaveToFile(LameFile);
 Res.Destroy;
end.
П. 1.4. ТЕКСТ МОДУЛЯ EM1_FORMAT.PAS
unit EM1_Format;
interface
uses
 SysUtils, AudioFormat;
type
 TEM1File = class(TAudioFile)
 public
 EM1Label: String;
 nChannels: Word;
 nSamplesPerSec: LongWord;
 nBytesPerSample: Word;
 nSamples: LongWord;
 procedure ReadAudioData(var AudioData: TAudioData);
 constructor Create(FileName: string; var AudioData: TAudioData);
 constructor Open(FileName: string);
 end;
implementation
constructor TEM1File.Create(FileName: string; var AudioData: TAudioData);
var
 Channel: Word;
 NumberOfBit, NumberOfSample, NumberOfSample0, i: Cardinal;
 Sample: Integer;
 Bit: Byte;
begin
 inherited Create(FileName);
 EM1Label := 'EM1 ';
 nChannels := AudioData.nChannels;
 nSamplesPerSec := AudioData.nSamplesPerSec;
 nBytesPerSample := AudioData.nBitsPerSample div 8;
 nSamples := AudioData.Data.Size div AudioData.nBlockAlign;
 WriteString(EM1Label, 4);
 Write(nChannels, 2);
 Write(nSamplesPerSec, 4);
 Write(nBytesPerSample, 2);
 Write(nSamples, 4);
 for Channel := 0 to nChannels-1 do
 begin
 NumberOfBit := Position*8;
 NumberOfSample0 := 0;
 NumberOfSample := 1;
 Bit := 0;
 while NumberOfSample < nSamples do
 begin
 while not AudioData.Extremum(NumberOfSample, Channel) do
 Inc(NumberOfSample);
 Inc(NumberOfSample);
 for i := 1 to NumberOfSample-NumberOfSample0 do
 begin
 WriteBit(NumberOfBit, Bit);
 Inc(NumberOfBit);
 end;
 Bit := 1 - Bit;
 NumberOfSample0 := NumberOfSample;
 end;
 NumberOfSample0 := 0;
 NumberOfSample := 1;
 while NumberOfSample < nSamples do
 begin
 while not AudioData.Extremum(NumberOfSample, Channel) do
 Inc(NumberOfSample);
 AudioData.ReadSample(NumberOfSample, Channel, Sample);
 Inc(NumberOfSample);
 Write(Sample, nBytesPerSample);
 NumberOfSample0 := NumberOfSample;
 end;
 end;
end;
constructor TEM1File.Open(FileName: String);
begin
 inherited Open(FileName);
 ReadString(EM1Label, 4);
 Read(nChannels, 2);
 Read(nSamplesPerSec, 4);
 Read(nBytesPerSample, 2);
 Read(nSamples, 4);
end;
procedure TEM1File.ReadAudioData(var AudioData: TAudioData);
var
 Channel: Word;
 NumberOfBit, NumberOfSample, NumberOfSample0, i: Cardinal;
 Sample, Sample0, Sample1: Integer;
 Bit: Byte;
 Value, Mult: LongWord;
begin
 AudioData.Data.Clear;
 AudioData.nChannels := nChannels;
 AudioData.nSamplesPerSec := nSamplesPerSec;
 AudioData.nBitsPerSample := nBytesPerSample*8;
 AudioData.Calculate_nBlockAlign;
 Position := 16;
 Mult := 1;
 for i := 0 to nBytesPerSample-1 do Mult := Mult*256;
 for Channel := 0 to nChannels-1 do
 begin
 NumberOfBit := Position*8;
 for i := 0 to nSamples-1 do
 begin
 ReadBit(NumberOfBit, Bit);
 if Bit = 0 then Sample := -32768 else Sample := 32767;
 AudioData.WriteSample(i, Channel, Sample);
 Inc(NumberOfBit);
 end;
 NumberOfSample0 := 0;
 NumberOfSample := 0;
 Sample0 := 0;
 while NumberOfSample < nSamples do
 begin
 AudioData.ReadSample(NumberOfSample, Channel, Sample1);
 Sample := Sample1;
 while (Sample = Sample1)and(NumberOfSample < nSamples) do
 begin
 Inc(NumberOfSample);
 if NumberOfSample < nSamples then
 AudioData.ReadSample(NumberOfSample, Channel, Sample);
 end;
 Value := 0;
 Read(Value, nBytesPerSample);
 if Value >= Mult/2 then Sample := Value - Mult else Sample := Value;
 for i := 0 to NumberOfSample-NumberOfSample0-1 do
 begin
 Sample1 := Sample0 + Round((Sample-Sample0)/2 - (Sample-Sample0)/2*Cos(i*Pi/(NumberOfSample-NumberOfSample0)));
 AudioData.WriteSample(NumberOfSample0+i, Channel, Sample1);
 end;
 NumberOfSample0 := NumberOfSample;
 Sample0 := Sample;
 end;
 end;
end;
end.
П. 1.5. ТЕКСТ МОДУЛЯ AUDIOFORMAT.PAS
unit AudioFormat;
interface
uses
 SysUtils, FileUtils;
type
 TAudioFile = class(TFile)
 end;
type
 TAudioData = class(TObject)
 public
 nChannels: Word;
 nSamplesPerSec: LongWord;
 nBitsPerSample: Word;
 nBlockAlign: Word;
 Data: TFile;
 constructor Create;
 destructor Destroy;
 procedure Calculate_nBlockAlign;
 procedure ReadSample(Number, Channel: LongInt; var Value: Integer);
 procedure WriteSample(Number, Channel: LongInt; Value: Integer);
 function Extremum(Number, Channel: LongInt): Boolean;
 private
 Name: String;
 end;
procedure CopyAudio(var AudioSource, AudioGeter: TAudioData; Start, Finish: Cardinal);
procedure DeleteAudio(var AudioData: TAudioData; Start, Finish: Cardinal);
procedure InsertAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
procedure OverwriteAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
procedure MixAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
procedure ReverseAudio(var AudioData: TAudioData; Start, Count: Cardinal);
procedure AddBrainWave(var AudioData: TAudioData; Start, Count, Freq1, Freq2: Integer);
procedure SetSpeedOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Speed: Real);
function ChangeSpeedOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Speed: Real): Cardinal;
procedure SetnSamplesPerSec(var AudioData: TAudioData; Value: Cardinal);
procedure SetnBitsPerSample(var AudioData: TAudioData; Value: Cardinal);
procedure SetnChannels(var AudioData: TAudioData; Value: Cardinal);
procedure SetVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
procedure Echo(var AudioData: TAudioData; Start, Count, Number, Delay: Cardinal; Volume: Real);
procedure Reverberation(var AudioData: TAudioData; Start, Count, Number, Delay: Cardinal; Volume: Real);
procedure ChangeVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
procedure ReChangeVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
procedure Normalize(var AudioData: TAudioData; Start, Count: Cardinal);
implementation
constructor TAudioData.Create;
var
 TempDir, FileName: String;
 i: Word;
begin
 inherited Create;
 TempDir := GetEnvironmentVariable('TEMP')+'\';
 i := 0;
 FileName := TempDir + '\' + '0.TAD';
 while FileExists(FileName) do
 begin
 Inc(i);
 Str(i, FileName);
 FileName := TempDir + '\' + FileName + '.TAD';
 end;
 Name := FileName;
 Data := TFile.Create(FileName);
end;
procedure TAudioData.Calculate_nBlockAlign;
begin
 nBlockAlign := nBitsPerSample div 8;
 if nBitsPerSample mod 8 <> 0 then Inc(nBlockAlign);
 nBlockAlign := nBlockAlign*nChannels;
end;
procedure TAudioData.ReadSample(Number, Channel: LongInt; var Value: Integer);
var
 i: Byte;
 Mult, AbsValue: LongWord;
begin
 Calculate_nBlockAlign;
 Data.Position := Number*nBlockAlign + Channel*(nBlockAlign div nChannels);
 AbsValue := 0;
 Data.Read(AbsValue, nBlockAlign div nChannels);
 Mult := 1;
 for i := 1 to nBlockAlign div nChannels do
 Mult := Mult*256;
 if nBitsPerSample>8 then
 if AbsValue >= Trunc(Mult/2) then Value := AbsValue - Mult else Value := AbsValue
 else Value := AbsValue-128;
end;
procedure TAudioData.WriteSample(Number, Channel: LongInt; Value: Integer);
var
 K: Byte;
 N: Cardinal;
begin
 Calculate_nBlockAlign;
 Data.Position := Number*nBlockAlign + Channel*(nBlockAlign div nChannels);
 if Data.Position>Data.Size then
 begin
 K := 0;
 N := Data.Position + nBlockAlign div nChannels;
 Data.Position := Data.Size;
 while Data.Position<=N do Data.Write(K, 1);
 Data.Position := Number*nBlockAlign + Channel*(nBlockAlign div nChannels);
 end;
 if nBitsPerSample<=8 then Value := Value+128;
 Data.Write(Value, nBlockAlign div nChannels);
end;
function TAudioData.Extremum(Number, Channel: LongInt): Boolean;
var
 Smp1, Smp, Smp2: Integer;
begin
 if (Number = 0) or (Number + 1 = Data.Size div nBlockAlign) then
 begin
 Extremum := True;
 Exit;
 end;
 ReadSample(Number-1, Channel, Smp1);
 ReadSample(Number, Channel, Smp);
 ReadSample(Number+1, Channel, Smp2);
 if (Smp1<Smp)and(Smp>Smp2) or (Smp1>Smp)and(Smp<Smp2) then
 Extremum := True
 else
 Extremum := False;
end;
destructor TAudioData.Destroy;
begin
 Data.Destroy;
 DeleteFile(Name);
 inherited Destroy;
end;
procedure CopyAudio(var AudioSource, AudioGeter: TAudioData; Start, Finish: Cardinal);
var
 i: Cardinal;
 Buf: array[0..63] of Byte;
begin
 AudioGeter.Data.Clear;
 AudioGeter.nChannels := AudioSource.nChannels;
 AudioGeter.nSamplesPerSec := AudioSource.nSamplesPerSec;
 AudioGeter.nBitsPerSample := AudioSource.nBitsPerSample;
 AudioGeter.Calculate_nBlockAlign;
 AudioSource.Data.Position := Start*AudioSource.nBlockAlign;
 for i := 1 to Abs(Finish-Start) do
 begin
 AudioSource.Data.Read(Buf, AudioSource.nBlockAlign);
 AudioGeter.Data.Write(Buf, AudioSource.nBlockAlign);
 end;
 AudioGeter.nChannels := AudioSource.nChannels;
 AudioGeter.nSamplesPerSec := AudioSource.nSamplesPerSec;
 AudioGeter.nBitsPerSample := AudioSource.nBitsPerSample;
end;
procedure InsertAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
var
 i: Cardinal;
 Buf: Byte;
begin
 if AudioSource.Data.Size = 0 then Exit;
 AudioGeter.Data.Insert(Start*AudioGeter.nBlockAlign, AudioSource.Data.Size);
 AudioSource.Data.Position := 0;
 AudioGeter.Data.Position := Start*AudioGeter.nBlockAlign;
 for i := 1 to AudioSource.Data.Size do
 begin
 AudioSource.Data.Read(Buf, 1);
 AudioGeter.Data.Write(Buf, 1);
 end;
end;
procedure DeleteAudio(var AudioData: TAudioData; Start, Finish: Cardinal);
begin
 AudioData.Data.Delete(Start*AudioData.nBlockAlign, Abs(Finish-Start)*AudioData.nBlockAlign);
end;
procedure OverwriteAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
var
 i: Cardinal;
 Buf: Byte;
begin
 if AudioSource.Data.Size = 0 then Exit;
 AudioSource.Data.Position := 0;
 AudioGeter.Data.Position := Start*AudioGeter.nBlockAlign;
 for i := 1 to AudioSource.Data.Size do
 begin
 AudioSource.Data.Read(Buf, 1);
 AudioGeter.Data.Write(Buf, 1);
 end;
end;
procedure MixAudio(var AudioSource, AudioGeter: TAudioData; Start: Cardinal);
var
 i, Channel, AudioSize: Cardinal;
 Value, MaxValue: Int64;
 Samp1, Samp2: Integer;
begin
 if AudioSource.Data.Size = 0 then Exit;
 AudioSize := AudioGeter.Data.Size div AudioGeter.nBlockAlign;
 MaxValue := 1; for i := 1 to AudioGeter.nBitsPerSample-1 do MaxValue := MaxValue*2;
 for i := 0 to AudioSource.Data.Size div AudioGeter.nBlockAlign - 1 do
 for Channel := 0 to AudioGeter.nChannels-1 do
 begin
 AudioSource.ReadSample(i, Channel, Samp1);
 if Start+i<AudioSize then
 AudioGeter.ReadSample(Start+i, Channel, Samp2)
 else
 Samp2 := 0;
 Value := Samp1 + Samp2;
 if (Value < -MaxValue)or(Value >= MaxValue) then
 Value := Trunc((Value)/2);
 AudioGeter.WriteSample(Start+i, Channel, Value);
 end;
end;
procedure ReverseAudio(var AudioData: TAudioData; Start, Count: Cardinal);
var
 i, AbsStart, AbsFinish, AbsCount: Cardinal;
 BufferStart: Cardinal;
 Buf: Int64;
 TempAudio: TAudioData;
begin
 TempAudio := TAudioData.Create;
 AbsStart := Start*AudioData.nBlockAlign;
 AbsCount := Count*AudioData.nBlockAlign;
 AbsFinish := AbsStart+AbsCount;
 i := AbsFinish;
 repeat
 if i-AbsStart>=MaxSizeOfBuffer then
 BufferStart := i - MaxSizeOfBuffer
 else
 BufferStart := AbsStart;
 AudioData.Data.Position := BufferStart;
 AudioData.Data.Read(Buf, 1);
 while i>BufferStart do
 begin
 i := i - AudioData.nBlockAlign;
 AudioData.Data.Position := i;
 AudioData.Data.Read(Buf, AudioData.nBlockAlign);
 TempAudio.Data.Write(Buf, AudioData.nBlockAlign);
 end;
 until i=AbsStart;
 AudioData.Data.Position := AbsStart;
 TempAudio.Data.Position := 0;
 for i := 1 to Count do
 begin
 TempAudio.Data.Read(Buf, AudioData.nBlockAlign);
 AudioData.Data.Write(Buf, AudioData.nBlockAlign);
 end;
 TempAudio.Destroy;
end;
procedure AddBrainWave(var AudioData: TAudioData; Start, Count, Freq1, Freq2: Integer);
var
 i, MaxAmplitude: Cardinal;
 T, TL, TR: Real;
 Freq: Integer;
 SampL, SampR: Integer;
begin
 if AudioData.nChannels = 1 then Exit;
 MaxAmplitude := 1;
 for i := 1 to AudioData.nBitsPerSample-1 do
 MaxAmplitude := MaxAmplitude*2;
 for i := Start to Start+Count-1 do
 begin
 Freq := Freq1 + Round((i-Start)*(Freq2-Freq1)/Count);
 T := 2*Pi/(AudioData.nSamplesPerSec/(Freq/100));
 TL := 2*Pi/(AudioData.nSamplesPerSec/(50+50*Freq/100));
 TR := 2*Pi/(AudioData.nSamplesPerSec/(50+50*Freq/100+Freq/100));
 AudioData.ReadSample(i, 0, SampL);
 AudioData.ReadSample(i, 1, SampR);
 SampL := Trunc(0.6*SampL+0.4*MaxAmplitude*Sin(i*TL));
 SampR := Trunc(0.6*SampR+0.4*MaxAmplitude*Sin(i*TR));
 AudioData.WriteSample(i, 0, SampL);
 AudioData.WriteSample(i, 1, SampR);
 end;
end;
procedure Normalize(var AudioData: TAudioData; Start, Count: Cardinal);
var
 i, MaxAmplitude, MaxVolume: Cardinal;
 Volume: Integer;
 K: Real;
 Channel: Word;
begin
 MaxAmplitude := 1;
 for i := 1 to AudioData.nBitsPerSample-1 do
 MaxAmplitude := MaxAmplitude*2;
 for Channel := 0 to AudioData.nChannels-1 do
 begin
 MaxVolume := 0;
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Volume);
 if Abs(Volume) > MaxVolume then MaxVolume := Abs(Volume);
 end;
 K := MaxAmplitude/MaxVolume;
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Volume);
 Volume := Round(Volume*K);
 AudioData.WriteSample(i, Channel, Volume);
 end;
 end;
end;
procedure SetSpeedOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Speed: Real);
var
 i, j, k, n, NewCount: Cardinal;
 Channel: Byte;
 Smp1, Smp2: Integer;
 Interval: Real;
 TempAudio: TAudioData;
 Buf: Int64;
begin
 if (Speed = 1) or (Speed = 0) then Exit;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.nBlockAlign := AudioData.nBlockAlign;
 NewCount := Round(Count/Speed);
 if Speed > 1 then
 begin
 i := NewCount;
 Interval := Speed;
 AudioData.Data.Position := Start*AudioData.nBlockAlign;
 while i<>0 do
 begin
 AudioData.Data.Read(Buf, AudioData.nBlockAlign);
 TempAudio.Data.Write(Buf, AudioData.nBlockAlign);
 AudioData.Data.Position := AudioData.Data.Position - AudioData.nBlockAlign + Trunc(Interval)*AudioData.nBlockAlign;
 Interval := Interval-Trunc(Interval)+Speed;
 Dec(i);
 end;
 end
 else
 begin
 Speed := 1/Speed;
 for Channel := 0 to AudioData.nChannels-1 do
 begin
 i := 0;
 j := 0;
 Interval := Speed;
 while i<>Count do
 begin
 AudioData.ReadSample(Start+i, Channel, Smp1);
 if i+1<>Count then
 AudioData.ReadSample(Start+i+1, Channel, Smp2)
 else
 Smp2 := Smp1;
 k := Trunc(Interval);
 for n := 0 to k-1 do
 TempAudio.WriteSample(j+n, Channel, Round(Smp1+(Smp2-Smp1)/k*n));
 Interval := Interval-Trunc(Interval)+Speed;
 Inc(i);
 Inc(j, k);
 end;
 end;
 end;
 DeleteAudio(AudioData, Start, Start+Count-1);
 InsertAudio(TempAudio, AudioData, Start);
 TempAudio.Destroy;
end;
function ChangeSpeedOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Speed: Real): Cardinal;
var
 i, j, k, n: Cardinal;
 Channel: Byte;
 Smp1, Smp2: Integer;
 Interval, FinalSpeed: Real;
 TempAudio: TAudioData;
 Buf: Int64;
begin
 if (Speed = 1) or (Speed = 0) then Exit;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.nBlockAlign := AudioData.nBlockAlign;
 FinalSpeed := Speed;
 if Speed > 1 then
 begin
 Speed := 1;
 Interval := Speed;
 AudioData.Data.Position := Start*AudioData.nBlockAlign;
 while AudioData.Data.Position div AudioData.nBlockAlign < Start+Count do
 begin
 AudioData.Data.Read(Buf, AudioData.nBlockAlign);
 TempAudio.Data.Write(Buf, AudioData.nBlockAlign);
 AudioData.Data.Position := AudioData.Data.Position - AudioData.nBlockAlign + Trunc(Interval)*AudioData.nBlockAlign;
 Interval := Interval-Trunc(Interval)+Speed;
 Speed := Speed+Trunc(Interval)*(FinalSpeed-1)/Count;
 end;
 end
 else
 begin
 FinalSpeed := 1/FinalSpeed;
 for Channel := 0 to AudioData.nChannels-1 do
 begin
 i := 0;
 j := 0;
 Speed := 1;
 Interval := Speed;
 while i<>Count do
 begin
 AudioData.ReadSample(Start+i, Channel, Smp1);
 if i+1<>Count then
 AudioData.ReadSample(Start+i+1, Channel, Smp2)
 else
 Smp2 := Smp1;
 k := Trunc(Interval);
 for n := 0 to k-1 do
 TempAudio.WriteSample(j+n, Channel, Round(Smp1+(Smp2-Smp1)/k*n));
 Interval := Interval-Trunc(Interval)+Speed;
 Inc(i);
 Inc(j, k);
 Speed := Speed+(FinalSpeed-1)/Count;
 end;
 end;
 end;
 DeleteAudio(AudioData, Start, Start+Count-1);
 InsertAudio(TempAudio, AudioData, Start);
 ChangeSpeedOfAudio := TempAudio.Data.Size div TempAudio.nBlockAlign;
 TempAudio.Destroy;
end;
procedure SetnSamplesPerSec(var AudioData: TAudioData; Value: Cardinal);
var
 AudioSize: Cardinal;
begin
 if AudioData.nSamplesPerSec = Value then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 if AudioSize <> 0 then SetSpeedOfAudio(AudioData, 0, AudioSize, AudioData.nSamplesPerSec/Value);
 AudioData.nSamplesPerSec := Value;
end;
procedure SetnBitsPerSample(var AudioData: TAudioData; Value: Cardinal);
var
 AudioSize, Max1, Max2, i: Cardinal;
 Channel: Word;
 Smp: Integer;
 Mult: Real;
 TempAudio: TAudioData;
begin
 if AudioData.nBitsPerSample = Value then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := Value;
 TempAudio.Calculate_nBlockAlign;
 Max1 := 1; for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do Max1 := Max1*256;
 Max2 := 1; for i := 1 to TempAudio.nBlockAlign div TempAudio.nChannels do Max2 := Max2*256;
 Mult := Max2/Max1;
 if AudioSize<>0 then
 begin
 for Channel := 0 to AudioData.nChannels-1 do
 for i := 0 to AudioSize-1 do
 begin
 AudioData.ReadSample(i, Channel, Smp);
 Smp := Trunc(Smp*Mult);
 TempAudio.WriteSample(i, Channel, Smp);
 end;
 AudioData.Data.Clear;
 OverwriteAudio(TempAudio, AudioData, 0);
 end;
 TempAudio.Destroy;
 AudioData.nBitsPerSample := Value;
 AudioData.Calculate_nBlockAlign;
end;
procedure SetnChannels(var AudioData: TAudioData; Value: Cardinal);
var
 AudioSize: Cardinal;
 TempAudio: TAudioData;
 i: Integer;
 Channel: Cardinal;
 Smp: Integer;
begin
 if AudioData.nChannels = Value then Exit;
 with AudioData do
 AudioSize := Data.Size div nBlockAlign;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := Value;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.Calculate_nBlockAlign;
 for i := 0 to AudioSize-1 do
 for Channel := 0 to Value-1 do
 begin
 if Channel < AudioData.nChannels then
 AudioData.ReadSample(i, Channel, Smp)
 else
 AudioData.ReadSample(i, AudioData.nChannels-1, Smp);
 TempAudio.WriteSample(i, Channel, Smp);
 end;
 AudioData.Data.Clear;
 AudioData.nChannels := Value;
 AudioData.Calculate_nBlockAlign;
 OverWriteAudio(TempAudio, AudioData, 0);
 TempAudio.Destroy;
end;
procedure SetVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
var
 MaxValue: Cardinal;
 Value: Integer;
 i: Cardinal;
 Channel: Word;
begin
 MaxValue := 1;
 for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do
 MaxValue := MaxValue*256;
 MaxValue := MaxValue div 2 - 1;
 for Channel := 0 to AudioData.nChannels-1 do
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Value);
 //Value := Trunc(Value*Exp(Volume/20));
 Value := Trunc(Value*Volume);
 if Abs(Value)>MaxValue then
 if Value<0 then Value := -MaxValue
 else Value := MaxValue;
 AudioData.WriteSample(i, Channel, Value);
 end;
end;
procedure Echo(var AudioData: TAudioData; Start, Count, Number, Delay: Cardinal; Volume: Real);
var
 TempAudio: TAudioData;
 i, j, DelaySmp: Cardinal;
 SummSmp: Int64;
 Mult: Real;
 Smp: Integer;
 Channel: Word;
 MaxValue: Cardinal;
begin
 for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do
 MaxValue := MaxValue*256;
 MaxValue := MaxValue div 2 - 1;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.Calculate_nBlockAlign;
 DelaySmp := Round(Delay*AudioData.nSamplesPerSec/1000);
 for Channel := 0 to AudioData.nChannels-1 do
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Smp);
 SummSmp := Smp;
 Mult := Volume;
 for j := 1 to Number do
 begin
 if i-Start < DelaySmp*j then
 Smp := 0
 else
 AudioData.ReadSample(i-DelaySmp*j, Channel, Smp);
 SummSmp := SummSmp + Round(Mult*Smp);
 Mult := Mult*Volume;
 end;
 Smp := Round(SummSmp/(Number+1));
 if Abs(Smp)>MaxValue then
 if Smp<0 then Smp := -MaxValue
 else Smp := MaxValue;
 TempAudio.WriteSample(i-Start, Channel, Smp);
 end;
 OverwriteAudio(TempAudio, AudioData, Start);
 TempAudio.Destroy;
 Normalize(AudioData, Start, Count);
end;
procedure Reverberation(var AudioData: TAudioData; Start, Count, Number, Delay: Cardinal; Volume: Real);
var
 TempAudio: TAudioData;
 i, j, k, DelaySmp: Cardinal;
 SummSmp: Int64;
 SmpBuf: array[0..64] of Int64;
 Mult: Real;
 Smp: Integer;
 Channel: Word;
 MaxValue: Cardinal;
begin
 for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do
 MaxValue := MaxValue*256;
 MaxValue := MaxValue div 2 - 1;
 TempAudio := TAudioData.Create;
 TempAudio.nChannels := AudioData.nChannels;
 TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
 TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
 TempAudio.Calculate_nBlockAlign;
 DelaySmp := Round(Delay*AudioData.nSamplesPerSec/1000);
 for Channel := 0 to AudioData.nChannels-1 do
 for i := Start to Start+Count-1 do
 begin
 for j := Number downto 0 do
 begin
 if i-Start < DelaySmp*j then
 Smp := 0
 else
 AudioData.ReadSample(i-DelaySmp*j, Channel, Smp);
 SmpBuf[j] := Smp;
 end;
 Mult := Volume;
 for j := 1 to Number do
 begin
 for k := 1 to Number do
 SmpBuf[k-1] := SmpBuf[k-1] + Round(SmpBuf[k]*Mult);
 Mult := Mult*Volume;
 end;
 Smp := Round(SmpBuf[0]/(Number+1));
 if Abs(Smp)>MaxValue then
 if Smp<0 then Smp := -MaxValue
 else Smp := MaxValue;
 TempAudio.WriteSample(i-Start, Channel, Smp);
 end;
 OverwriteAudio(TempAudio, AudioData, Start);
 TempAudio.Destroy;
 Normalize(AudioData, Start, Count);
end;
procedure ChangeVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
var
 MaxValue: Cardinal;
 Value: Integer;
 i: Cardinal;
 FinalVolume: Real;
 Channel: Word;
begin
 MaxValue := 1;
 for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do
 MaxValue := MaxValue*256;
 MaxValue := MaxValue div 2 - 1;
 FinalVolume := Volume;
 for Channel := 0 to AudioData.nChannels-1 do
 begin
 Volume := 1;
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Value);
 //Value := Trunc(Value*Exp(Volume/20));
 Value := Trunc(Value*Volume);
 if Abs(Value)>MaxValue then
 if Value<0 then Value := -MaxValue
 else Value := MaxValue;
 AudioData.WriteSample(i, Channel, Value);
 Volume := Volume + (FinalVolume-1)/Count;
 end;
 end;
end;
procedure ReChangeVolumeOfAudio(var AudioData: TAudioData; Start, Count: Cardinal; Volume: Real);
var
 MaxValue: Cardinal;
 Value: Integer;
 i: Cardinal;
 FinalVolume: Real;
 Channel: Word;
begin
 MaxValue := 1;
 for i := 1 to AudioData.nBlockAlign div AudioData.nChannels do
 MaxValue := MaxValue*256;
 MaxValue := MaxValue div 2 - 1;
 FinalVolume := Volume;
 for Channel := 0 to AudioData.nChannels-1 do
 begin
 Volume := 0;
 for i := Start to Start+Count-1 do
 begin
 AudioData.ReadSample(i, Channel, Value);
 //Value := Trunc(Value*Exp(Volume/20));
 Value := Trunc(Value*Volume);
 if Abs(Value)>MaxValue then
 if Value<0 then Value := -MaxValue
 else Value := MaxValue;
 AudioData.WriteSample(i, Channel, Value);
 Volume := Volume + FinalVolume/Count;
 end;
 end;
end;
end.

ПРИЛОЖЕНИЕ 2

РУКОВОДСТВО ПРОГРАММИСТА
– изменение темпа: замедление или ускорение скорости воспроизведения звукового сигнала;
– изменение общего уровня громкости: увеличение или уменьшение общего уровня громкости.;
– эффект возрастания громкости: плавное увеличение громкости от нулевого уровня в начале фрагмента до максимального в конце;
– эффект затухания громкости: плавное уменьшение громкости от максимального уровня в начале фрагмента до нулевого в конце.
Обработка сигнала – это сложная и, главное, ресурсоемкая процедура. Она сравнительно недавно стала проводиться в цифровых устройствах – раньше различные эффекты звучания и другие достигались путем обработки звука в аналоговых приборах. В аналоговой аппаратуре звук в виде электрических колебаний проходит через различные тракты (блоки электрических элементов), чем достигается изменение фазы, спектра и амплитуды сигнала. Однако такой способ обработки имеет массу недостатков. Возможность же использования цифровых устройств имеет неоспоримые преимущества. Качество обработки сигналов в них намного меньше зависит от качества аппаратуры. Кроме того, для различных манипуляций со звуком не требуется постоянная смена оборудования. И, самое главное, поскольку обработка ведется программным путем, для нее открываются просто невероятные возможности, которые ограничены лишь мощностью компьютеров (а она увеличивается с каждым днем) и фантазией человека.

1. РАЗРАБОТКА СИСТЕМЫ ОБРАБОТКИ АУДИОИНФОРМАЦИИ

1.1.                Обоснование целесообразности разработки системы обработки аудиоинформации

1.1.1.        Назначение системы

Система обработки аудиоинформации реализует обработку звуковых сигналов. Система предназначена для обработки звуковых сигналов, записанных в звуковых файлах различных форматов. Обработка позволяет внести необходимые изменения в исходный звуковой файл: редактирование его структуры, основных параметров, позволяет применить различные эффекты к файлу. Система также позволяет осуществить кодирование исходного файла с целью уменьшения занимаемого им размера без явной потери качества.

1.1.2.        Характеристика функциональной структуры системы

Функциональная схема системы приведена на рис. 1.1.
Обработка аудиофайлов состоит из следующих этапов:
1)     ввод звуковых сигналов в подсистему обработки и фильтрации сигнала, результатом работы которой является измененный звуковой сигнал, записанный в файле и статистические данные, полученные при анализе звукового сигнала;
2)     ввод отредактированного звукового сигнала в подсистему кодирования данных, результатом которой является файл со сжатым звуковым сигналом.
Результатом работы системы является измененный и/или сжатый звуковой файл.

Функциональная схема системы обработки аудиоинформации

Рис. 1.1

1.1.3.                Обоснование цели создания системы

Обработка сигнала – это сложная и, главное, ресурсоемкая процедура. Она сравнительно недавно стала проводиться в цифровых устройствах – раньше различные эффекты звучания и другие достигались путем обработки звука в аналоговых приборах. В аналоговой аппаратуре звук в виде электрических колебаний проходит через различные тракты (блоки электрических элементов), чем достигается изменение фазы, спектра и амплитуды сигнала. Однако такой способ обработки имеет массу недостатков. Во-первых, страдает качество обработки, ведь каждый аналоговый элемент имеет свою погрешность, а несколько десятков элементов могут критически повлиять на точность и качество желаемого результата. А во-вторых, и это, пожалуй, самое главное, почти каждый отдельный эффект достигается путем использования отдельного устройства, когда каждое такое устройство может стоить очень дорого. Возможность же использования цифровых устройств имеет неоспоримые преимущества. Качество обработки сигналов в них намного меньше зависит от качества аппаратуры, главное – это качественно оцифровать звук и иметь возможность качественно его воспроизводить, и тогда качество обработки ложится уже только на программный механизм. Кроме того, для различных манипуляций со звуком не требуется постоянная смена оборудования. И, самое главное, поскольку обработка ведется программным путем, для нее открываются просто невероятные возможности, которые ограничены лишь мощностью компьютеров (а она увеличивается с каждым днем) и фантазией человека.
К преобразованию звука прибегают в основном с целью изменения каких-то характеристик звука.
Принципиально, целью обработки звука является придание существующему звуку каких-то новых качеств или устранение нежелательных. Звуковые эффекты относятся к тем преобразованиям звука, которые придают звучанию новые формы или полностью изменяют звуковую информацию. Аппаратную реализацию звуковые эффекты находят в цифровых сигнальных процессорах (DSP). Любой более или менее приличный MIDI-синтезатор имеет встроенный эффект-процессор той или иной сложности (эффект-процессор представляет собой один или несколько DSP). Сложные эффект-процессоры "умеют" накладывать на звуковой сигнал сразу несколько различных эффектов, причем, отдельно для каждого канала, позволяя регулировать параметры эффектов в режиме реального времени. Однако стоимость таких эффект-процессоров чрезвычайно высока (как и стоимость любого другого высокопроизводительного микропроцессора), поэтому профессиональные DSP устанавливаются только на качественной музыкальной аппаратуре. На более или менее дешевых звуковых платах часто устанавливается DSP с упрощенным набором возможностей: наложение одного или нескольких эффектов на все каналы одновременно. Аппаратный эффект-процессор - это, безусловно, хорошо, но обработать звук на высоком уровне можно и программным способом.
Оцифрованный аудио сигнал «в чистом виде» (например, в форме одной из рассмотренных выше вариаций ИКМ) является достаточно точной, но не самой компактной формой записи исходного аналогового сигнала. объем памяти, требуемый для ее хранения в исходном цифровом виде, оказывается очень внушительным. Поэтому хранение относительно больших объемов аудио данных, гарантирующее достаточно хорошее качество звучания, требует применения разных «ухищрений», позволяющих уплотнить данные.

1.1.4.                Обоснование состава автоматизируемых задач

Реализация системы обработки аудиоинформации позволит интегрировать в едином интерфейсе все этапы обработки аудиоинформации:
1)                     редактирование структуры звукового файла;
2)           изменение параметров цифрового звука (частота дискретизации, битрейт, число каналов);
3)                     редактирование темпа звука;
4)                     изменение общего уровня громкости;
5)           эффекты возрастающей и затухающей громкости, эха и реверберации;
6)                     кодирование (сжатие) аудиоданных.
Редактирование структуры файла необходимо для изменения отдельных частей файла, это позволит удалять, копировать и вставлять части звукового сигнала. Изменение параметров цифрового звука необходимо, например, для уменьшения размера звукового файла, когда не так важно качество звучания. Редактирование темпа позволит замедлить и ускорить скорость воспроизведения звукового сигнала. Применение эффектов позволит придать звуку необходимые характеристики звучания.

1.2.    Аналитический обзор

Тема программного обеспечения очень широка, поэтому здесь мы только вкратце обсудим основные представители программ для обработки звука.
Основные возможности таких программ это, как минимум, обеспечение возможности записи (оцифровки) аудио и сохранение на диск. Развитые представители такого рода программ позволяют намного больше: запись, многоканальное сведение аудио на нескольких виртуальных дорожках, обработка специальными эффектами (как встроенными, так и подключаемыми извне – об этом позже), очистка от шумов, имеют развитую навигацию и инструментарий в виде спектроскопа и прочих виртуальных приборов, управление/управляемость внешними устройствами, преобразование аудио из формата в формат, генерация сигналов, запись на компакт диски и многое другое. Некоторые из таких программ: Cool Edit Pro (Syntrillium), Sound Forge (Sonic Foundry), Nuendo (Steinberg), Samplitude Producer (Magix), Wavelab (Steinberg).

1.2.1.      Cool Edit Pro 2.0

Редактирование и сведение аудио на 128 дорожках, 45 встроенных DSP-эффектов, включая инструменты для мастеринга, анализа и реставрации аудио, 32-битная обработка, поддержка аудио с параметрами 24 бит / 192 КГц, мощный инструментарии для работы с петлями (loops), поддержка DirectX, а также управление SMPTE/MTC, поддержка работы с видео и MIDI и прочее.

1.2.2.      Sound Forge 6.0a

Мощные возможности не деструктивного редактирования, многозадачная фоновая обработка заданий, поддержка файлов с параметрами до 32 бит / 192 КГц, менеджер предустановок, поддержка файлов более 4 Гб, работа с видео, большой набор эффектов обработки, восстановление после зависаний, предпрослушивание примененных эффектов, спектральный анализатор и прочее.

1.2.3.      Вывод по аналитическому обзору

В наборе программ пользователя, занимающегося обработкой звука, имеется множество разных инструментов, так было раньше и так будет впредь – универсальных комбайнов для работы со звуком не бывает. Однако, не смотря на все разнообразие ПО, в программах часто используются схожие механизмы для обработки звука (например, процессоры эффектов и прочие). На каком-то этапе разработки аудио ПО, производители поняли, что удобнее сделать в своих программах возможность подключения внешних инструментов, чем каждый раз создавать заново инструменты для каждой отдельной программы. Так что многие программы, относящиеся к той или иной группе ПО, позволяют подключать так называемые «плагины» - внешние подключаемые модули, расширяющие возможности обработки звука. Это стало возможным в результате появления нескольких стандартов на интерфейс между программой и подключаемым модулем. На сегодняшний день существуют два основных стандарта на интерфейс: DX и VST. Существование стандартов позволяет подключать один и тот же плагин к совершенно разным программам, не заботясь о возникновении конфликтов и неполадок. Говоря о самих плагинах, надо сказать, что это просто огромное семейство программ. Обычно, один плагин является механизмом, реализующим какой-то конкретный эффект, например, реверберацию или низкочастотный фильтр. Но все вышеперечисленные средства для редактирования аудиоданных имеют закрытый исходный код.

1.3.        Основные требования к системе

1.3.1.  Основные цели создания системы и критерии эффективности ее функционирования

Создание системы обработки аудиоинформации позволит получить преобразованный звуковой сигнал с заданными характеристиками звучания, а также сжатие измененного звукового файла для уменьшения занимаемого им размера без значительной потери качества звучания.
Для оценки эффективности работы системы обработки аудиоинформации можно использовать качество получаемых на выходе звуковых сигналов. Для определения качества кодирования звуковых данных можно использовать оценку размера полученных закодированных звуковых файлов и исходных.

1.3.2.      Функциональное назначение системы

Автоматизация процесса обработки аудиоинформации подразумевает реализацию в системе определенных средств и функций. Следует выделить функциональных особенности, которыми должна обладать система:
1)     возможность открытия и анализа файлов форматов Microsoft Wave, MP3 и Electronic Music;
2)     отображение структуры звукового сигнала, записанного в файле, в графическом виде с возможностью изменения масштаба;
3)     обеспечение возможности основных операций редактирования: выделение части сигнала, ее удаление, копирование и вставку. Обеспечение возможности вставки звукового сигнала из другого файла;
4)     возможность изменения основных параметров цифрового звука: частоты дискретизации, битрейта, числа каналов;
5)     изменение темпа(скорости) звукового сигнала, уровня громкости;
6)     применение звуковых эффектов к сигналу, с указанием необходимых для них параметров (для эффекта эха: количество откликов, время между откликами, громкость отклика относительно предыдущего; для эффекта реверберации: количество отражений, задержка отраженного сигнала, громкость отражения относительно предыдущего; для эффектов возрастающей и затухающей громкости: громкость относительно текущей);
7)     сжатие полученного сигнала для более компактного хранения с возможностью последующего извлечения.

1.3.3.      Особенности системы и условия ее эксплуатации

Система обработки аудиоинформации предназначена для работы с цифровыми звуковыми сигналами, записанными в файлах одного из следующих форматов: Microsoft Wave, MP3, Electronic Music. Объем информации, обрабатываемой системой, достаточно велик и может достигать нескольких десятков мегабайт. Эти особенности накладывают ограничения на использование непроизводительных и медленных алгоритмов.

1.3.4.      Требования к функциональной структуре

Построение системы обработки аудиоинформации предполагает модульную структуру. Система включает в себя 2 подсистемы: подсистему обработки и фильтрации сигнала, подсистему кодирования данных. Общий интерфейс и возможность доступа ко всем модулям в составе каждой подсистемы должна обеспечивать оболочка. Таким образом, существует две оболочки. Первая реализует интерфейс для редактирования звукового сигнала, его параметров, применение к нему различных эффектов. Вторая реализует интерфейс для кодирования(сжатия) отредактированного звукового сигнала. Обмен между подсистемами происходит через звуковые файлы.

1.3.5.      Требования к техническому обеспечению

Задача обработки звуковых сигналов в системе обработки аудиоинформации связана с автоматическим анализом больших массивов аудио информации. Преобразования, проводимые в системе, должны проводиться в процессе интерактивного взаимодействия с пользователем, поэтому паузы на обработку не должны превышать нескольких минут. Исходя из этого, сформулированы требования к техническим характеристикам персонального компьютера, на котором будет функционировать система. Требования сведены в табл. 1.1.
Таблица 1.1
Технические характеристики персонального компьютера

Наименование	Значение
Частота процессора, МГц	от 900
Объем оперативной памяти, Мб	от 128
Разрешение экрана монитора	не менее 1024x768

1.3.6.      Требования к информационному обеспечению

Система обработки аудиоинформации предназначена для обработки звуковых сигналов, записанных в звуковых файлах. Файлы должны быть одного из следующих форматов: Microsoft Wave (*.wav), MP3, Electronic music (*.em1)
Основным видом информации, обрабатываемом в системе, является звуковая информация в цифровом представлении. Такой вид данных воспринимается человеком непосредственно, поэтому необходимо обеспечить возможность прослушивания преобразованных сигналов на различных этапах обработки, а также их графическую визуализацию.

1.3.7.      Требования к программному обеспечению

Систему обработки аудиоинформации целесообразно разрабатывать для функционирования под управлением операционной системой семейства Windows, так как ОС данного класса наиболее широко распространены в современном мире. Платформами для разработки выбраны среды для разработки приложений Borland Delphi 7 (подсистема обработки и филбтрации сигнала) и Microsoft Visual C++ 2003 (подсистема кодирования данных). Эта среда поддерживают алгоритмические языки Pascal и C++ соответственно и обладают при этом возможностями быстрой разработки и проектирования визуальных интерфейсов.

1.4.        Основные технические решения проекта системы

1.4.1.      Решение по комплексу технических средств

Как уже отмечалось в п.п. 1.3.5, для достижения удобного пользователю режима функционирования системы необходимо следующая минимальная конфигурация персонального компьютера: частота процессора 900 МГц, объем оперативной памяти 128 Мб, монитор, поддерживающий разрешение 1024x768 точек. Также желательно наличие следующих периферийных технических средств: микрофон или другое записывающее устройство для получения исходных звуковых сигналов для их последующей обработки в системе, а также устройства вывода звуковых сигналов (колонки) для прослушивания полученных звуковых сигналов и оценки результатов работы системы.

1.4.2.      Описание системы программного обеспечения

Для реализации и функционирования проекта необходимо общесистемное программное обеспечение ОС Windows XP, в основе которой лежит ядро, характеризуемое 32-разрядной вычислительной архитектурой и полностью защищенной моделью памяти, что обеспечивает надежную вычислительную среду.
Разработка системы обработки аудиоинформации и ее подсистем будет вестись с использованием сред для разработки приложений Borland Delphi 7 и Microsoft Visual C++ 2003. Эти среды разработки включают в себя высокопроизводительный 32-битный компилятор, что позволяет оптимизировать создаваемый код, а также обширный набор средств, которые повышают производительность труда программистов и сокращают продолжительность цикла разработки. Многофункциональные интегрированные среды разработки включают компилятор, удовлетворяющий стандарта ANSI/ISO, встроенный дизайнер форм, богатый набор средств для работы с компонентами, менеджер проектов и отладчик. Удобство разработки и эффективность созданных в данных средах разработки программ делают их оптимальным выбором для построения исследовательской системы, какой является система обработки аудиоинформации.

2.                РАЗРАБОТКА ПОДСИСТЕМЫ ОБРАБОТКИ И ФИЛЬТРАЦИИ СИГНАЛА

2.1.         Описание постановки задачи обработки и фильтрации звукового сигнала

2.1.1.                Характеристика задачи

При разработке подсистемы обработки и фильтрации звукового сигнала требуется выполнить следующие задачи:
1)     изучение структуры звуковых файлов различных форматов и реализация возможностей чтения этих форматов для последующей обработки;
2)     разработка алгоритмов, позволяющих преобразовывать исходный звуковой сигнал с целью изменения характеристик звучания;
3)     программная реализация алгоритмов, позволяющих преобразовывать исходный звуковой сигнал с целью изменения характеристик звучания.
Автоматизация процесса обработки и фильтрации звукового сигнала подразумевает реализацию в подсистеме определенных средств и функций. Следует выделить функциональных особенностей, которыми должна обладать подсистема:
1)     возможность открытия и анализа файлов форматов Microsoft Wave, MP3 и Electronic Music;
2)     отображение структуры звукового сигнала, записанного в файле, в графическом виде с возможностью изменения масштаба;
3)     обеспечение возможности основных операций редактирования: выделение части сигнала, ее удаление, копирование и вставку. Обеспечение возможности вставки звукового сигнала из другого файла;
4)     возможность изменения основных параметров цифрового звука: частоты дискретизации, битрейта, числа каналов;
5)     изменение темпа (скорости) звукового сигнала, уровня громкости, обращение звукового сигнала;
6)     применение звуковых эффектов к сигналу с указанием необходимых для них параметров.
Перечислим реализуемые звуковые эффекты с указанием их параметров:
– эффект эха: реализация повторения звукового сигнала с помощью временных преобразований таким образом, чтобы человеческое ухо воспринимало полученный сигнал как эхо (параметры: количество откликов, время между откликами, громкость отклика относительно предыдущего);
– эффект реверберации: придание звучанию объемности, характерной для большого зала, где каждый звук порождает соответствующий, медленно угасающий отзвук; отличается тем, что на входной сигнал накладывается задержанный во времени выходной сигнал, а не задержанная копия входного (параметры: количество отражений, задержка отраженного сигнала, громкость отражения относительно предыдущего);
– эффекты возрастающей и затухающей громкости: плавное увеличение громкости от нулевого уровня в начале фрагмента до максимального в конце и наоборот соответственно (параметр: величина громкости в процентах от текущей).
Полученный измененный звуковой сигнал поступает в подсистему кодирования данных для уменьшения занимаемого им размера.

2.1.2.      Вхоная информация

Входной информацией для подсистемы является цифровой звуковой сигнал, записанный в звуковом файле определенного формата. Формат входного звукового файла представлен в табл.2.1.
Файл этого формата содержит заголовок, описывающий общие параметры файла, и один или более фрагментов, каждый из которых представляет собой волновую форму или вспомогательную информацию.
Таблица 2.1
Структура звукового файла формата Microsoft RIFF/WAVE

СМЕЩЕНИЕ ОТ НАЧАЛА ФАЙЛА	ДЛИНА	ОПИСАНИЕ
0	4	ИДЕНТИФИКАТОР ФОРМАТА ( 'RIFF ')
4	4	ДЛИНА БЛОКА ДАННЫХ ( ДЛИНА ФАЙЛА БЕЗ ЭТОГО ЗАГОЛОВКА)
8	4	ИДЕНТИФИКАТОР БЛОКА ЗВУКОВЫХ ДАННЫХ ( 'WAVE‘ )
12	4	ИДЕНТИФИКАТОР ПОДБЛОКА ЗАГОЛОВКА (‘fmt_‘)
16	4	ДЛИНА ПОДБЛОКА ЗАГОЛОВКА
20	2	ТИП ФОРМАТА ПРЕДСТАВЛЕНИЯ ДАННЫХ
22	2	ЧИСЛО КАНАЛОВ ( 1 - МОНО, 2 – СТЕРЕО )
24	2/4	ЧАСТОТА ДИСКРЕТИЗАЦИИ, ГЦ
26/28	2/4	СКОРОСТЬ ПЕРЕДАЧИ ДАННЫХ, БАЙТ/С (ЧИСЛО КАНАЛОВ х ЧАСТОТА ДИСКРЕТИЗАЦИИ х РАЗРЯДНОСТЬ В БАЙТАХ)
28/32	2	ВЫРАВНИВАНИЕ БЛОКА ДАННЫХ (ЧИСЛО КАНАЛОВ х РАЗРЯДНОСТЬ)
30/34	2	РАЗРЯДНОСТЬ - ЧИСЛО БИТ НА ОДИН ОТСЧЕТ ( 8, 16 )
32/36	4	ИДЕНТИФИКАТОР ПОДБЛОКА ДАННЫХ ( ‘DATA')
36/40	4	ДЛИНА ЗВУКОВЫХ ДАННЫХ
40/44		ЗВУКОВЫЕ ДАННЫЕ (0..255 ПРИ 8 БИТ И -32768..32767 ПРИ 16 БИТ)

2.1.3.      Выходная информация

Выходной информацией для данной задачи является измененный звуковой сигнал, записанный в файле, структура которого аналогична описанной в п.2.1.2.

2.1.4.      Математическая постановка задачи

Спектр – один из важнейших инструментов анализа и обработки звука. Французский математик Фурье (1768-1830) и его последователи доказали, что любую, обязательно периодическую функцию, в случае ее соответствия некоторым математическим условиям можно разложить в тригонометричес-кий ряд Фурье:

,

(1)

где a_i, b_i – это так называемые коэффициенты Фурье, рассчитывающиеся по некоторой формуле.
На рис. 2.1 представлена цифровая форма представления звука.
Цифровая форма представления звукового сигнала

Рис. 2.1
Основные параметры цифрового звука:
– частота дискретизации: определяется интервалом времени, через кото-рое происходит измерение значения амплитуды аналогового сигнала;
– битрейт: разрядность квантования; количество бит, которым описывает-ся одна секунда звукового сигнала;
– число каналов: число источников звука, через которые воспроизводятся звуковые сигналы.
Звуковые сигналы поступают на вход системы в цифровом виде – в виде звуковых файлов, структура которых описана в п.2.1.2.
Задача обработки и фильтрации заключается в извлечении и обработки необходимых данных из файла.
С помощью заголовка звукового файла можно прочитать и изменить описанные основные параметры звукового сигнала, записанного в файле.
Для изменения звукового сигнала и применения к нему эффектов необходимо прочитать и отредактировать звуковые данные из основной части файла.
Математическое представление звуковых эффектов и их параметров:
Эффект реверберации.
На рис. 2.2 представлен исходный звуковой сигнал, а на рис. 2.3 применение к исходному сигналу эффекта реверберации с указанием параметров На оси абцисс откладывается время, а по оси ординат значение амплитуды (громкости) звукового сигнала в определенный момент времени.
Исходный сигнал

Рис.2.2
Эффект реверберации

T – время между отражениями;
h1 – громкость исходного звукового сигнала;
h2 – громкость отраженного сигнала.
Рис. 2.3
В данном случае h1=h2, то есть громкость отраженного сигнала равна громкости исходного сигнала.
Количество отражений в данном случае равно 1.
Эффект эха.
На рис. 2.4 представлен исходный звуковой сигнал, а на рис. 2.5 применение к исходному сигналу эффекта эха с указанием параметров На оси абцисс откладывается время, а по оси ординат значение амплитуды (громкости) звукового сигнала в определенный момент времени.
Исходный сигнал

Рис. 2.4
Эффект эха

T – время между откликами;
h1 – громкость исходного звукового сигнала;
h2 – громкость отклика.
Рис.2.5.
В данном случае h2=h1/2, то есть громкость отклика в два раза меньше громкости исходного сигнала .
Количество откликов в данном случае равно 1.
Изменение темпа.
На рис. 2.6 представлен исходный звуковой сигнал. На рис. 2.7 представлен измененный звуковой сигнал с уменьшенным в два раза темпом, на рис. 2.8 – с увеличенным в два раза темпом. На оси абцисс откладывается время, а по оси ординат значение амплитуды (громкости) звукового сигнала в определенный момент времени.
 Исходный сигнал                           Увеличение темпа
                
 Рис. 2.6                                          Рис. 2.7
Уменьшение темпа

Рис. 2.8
Изменение общего уровня громкости
На рис. 2.9 представлен исходный звуковой сигнал. На рис. 2.10 представлен измененный звуковой сигнал с уменьшенной в два раза громкостью, на рис. 2.11 – с увеличенной в два раза громкостью. На оси абцисс откладывается время, а по оси ординат значение амплитуды (громкости) звукового сигнала в определенный момент времени.
          Исходный сигнал                          Уменьшение громкости
                
 Рис. 2.9                                          Рис. 2.10
Увеличение громкости

Рис. 2.11
Эффекты возрастающей и затухающей громкости.
На рис. 2.12 представлен исходный звуковой сигнал, а на рис. 2.13 и рис. 2.14 применение к исходному сигналу эффекта возрастающей и затухающей громкости соответственно. На оси абцисс откладывается время, а по оси ординат значение амплитуды (громкости) звукового сигнала в определенный момент времени.
 Исходный сигнал                                    Возрастание громкости
             
 Рис. 2.12                                        Рис.2.13
Затухание громкости

Рис. 2.14
Обращение звукового сигнала. На рис. 2.15 представлен исходный звуковой сигнал, а на рис. 2.16 – обращенный.
 Исходный сигнал                                    Обращенный сигнал
                
 Рис. 2.15                                         Рис. 2.16

2.2.        Описание алгоритма создания эффекта реверберации

2.2.1.                Назначение и характеристика алгоритма создания эффекта реверберации

Данный алгоритм применяется к исходному звуковому сигналу для создания эффекта реверберации: придание звучанию объемности, характерной для большого зала, где каждый звук порождает соответствующий, медленно угасающий отзвук. Получается путем добавления к исходному сигналу затухающей серии его задержанных во времени копий. Это имитирует затухание звука в помещении, когда за счет многократных отражений от стен, потолка и прочих поверхностей звук приобретает полноту и гулкость, а после прекращения звучания источника затухает не сразу, а постепенно. При этом время между последовательными отзвуками ассоциируется с величиной помещения, а их интенсивность – с его гулкостью.

2.2.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов.
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала.
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации, битрейта и размера файла.
T_i – T_i-1 определяется частотой дискретизации.
При реализации алгоритма учитываются следующие параметры эффекта реверберации, которые подаются в качестве параметров на вход алгоритма:
To – время между отражениями;
Гр – громкость отражения относительно предыдущего в процентах;
Kол – количество отражений.

2.2.3.      Результаты решения

В результате реализации алгоритма формируются новые массивы амплитуд и значений времени A’ и T’. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.2.4.                Математическое описание алгоритма создания эффекта реверберации

Для получения выходных массивов A’ и T’ необходимо предварительно получить Кол пар дополнительных массивов А(А1,А2,…,Акол) и Т(Т1,Т2,…,Ткол) с отражениями, а затем совместить их:
m – размерности получаемых массивов A’ и T’
m = n + n*Кол;
T1_i = T_i + 1*То;
T2_i = T_i + 2*То;
…
ТКол_i = T_i + Кол*То;
A1_i = Гр/100*A_i;
A2_i = Гр/100*A1_i;
…
Aкол = Гр/100*A[кол-1]_i
Описание используемых обозначений приведено в п.2.2.2.
Затем все полученные массивы амплитуд и времен объединяются в один общий массив (A’ и T’ соответственно).

2.2.5.      Алгоритм создания эффекта реверберации

1.    i::=1;
2.    MaxValue::=MaxValue*256;
3.    i::=i+1;
4.    Если i≤(AudioData.nBlockAlign/AudioData.nChannels),то переход к п.2 иначе к п.5;
5.    MaxValue::=MaxValue/2 – 1;
6.    TempAudio.nChannels ::= AudioData.nChannels;
7.    TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
8.    TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
9.    DelaySmp := Round(Delay*AudioData.nSamplesPerSec/1000);
10.                      Channel :: =0;
11.                      Если Channel > (AudioData.nChannels-1),то переход к п. 38 иначе к п.12
12.                      i :: = Start;
13.                      Если i > (Start+Count-1), то переход к п. 37 иначе к п.14;
14.                      j :: = Number;
15.                      Если j < 0, то переход к п.21 иначе к п.16;
16.                      Если (i - Start) < (DelaySmp*j), то переход к п.17 иначе к п.18;
17.                      Smp ::= 0;
18.                      Прочитать из файла значение Smp;
19.                      SmpBuf [j] ::= Smp;
20.                      j ::= j+1; переход к п.15;
21.                      Mult ::= Volume;
22.                      j::=1;
23.                      Если j>Number, то переход к п.30 иначе к п.24;
24.                      k::=1;
25.                      Если k>Number, то переход к п.28 иначе к п.26;
26.                      SmpBuf[k-1] := SmpBuf[k-1] + Round(SmpBuf[k]*Mult);
27.                      k::=k+1; переход к п.25;
28.                      Mult ::= Mult*Volume;
29.                      j::=j+1; переход к п.23;
30.                      Smp := Round(SmpBuf[0]/(Number+1));
31.                      Если |Smp|>MaxValue, то переход к п.32 иначе к п.35;
32.                      Если Smp<0, то переход к п.33 иначе к п.34;
33.                      Smp::= - MaxValue;
34.                      Smp::=MaxValue;
35.                      Запись Smp в TempAudio;
36.                      i::=i+1; переход к п.13;
37.                      Сhannel ::= Channel+1; переход к п.11;
38.                      AudioData ::= TempAudio;
39.                      Конец.

2.2.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры применения эффекта реверберации с различными параметрами.

2.2.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.3.         Описание алгоритма создания эффекта эха

2.3.1.                Назначение и характеристика алгоритма создания эффекта эха

Данный алгоритм применяется к исходному звуковому сигналу для создания эффекта эха: реализация повторения звукового сигнала с помощью временных преобразований таким образом, чтобы человеческое ухо воспринимало полученный сигнал как эхо. При этом слух перестает субъективно воспринимать отражения, как призвуки основного сигнала, и начинает воспринимать их как повторения. Эхо обычно реализуется так же, как и естественное - с затуханием повторяющихся копий.

2.3.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени;
n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации;
При реализации алгоритма учитываются следующие параметры эффекта эха, которые подаются в качестве параметров на вход алгоритма:
To – время между откликами;
Гр – громкость отклика относительно предыдущего в процентах;
Kол – количество откликов.

2.3.3.      Результаты решения

В результате реализации алгоритма формируются новые массивы амплитуд и значений времени A’ и T’. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.3.4.      Математическое описание алгоритма создания эффекта эха

Для получения выходных массивов A’ и T’ необходимо предварительно получить Кол пар дополнительных массивов А(А1,А2,…,Акол) и Т(Т1,Т2,…,Ткол) с откликами, а затем совместить их:
m – размерности получаемых массивов A’ и T’;
m = n + n*Кол + То;
T1_i = T_n + T_i + То;
T2_i = 2*T_n + T_i + 2*То;
…
ТКол_i =Кол*Т_n + T_i + Кол*То;
A1_i = Гр/100*A_i;
A2_i = Гр/100*A1_i;
…
Aкол_i = Гр/100*A[кол-1]_i
Описание используемых обозначений приведено в п.2.3.2.
Затем все полученные массивы амплитуд и времен объединяются в один общий массив (A’ и T’ соответственно).

2.3.5.      Алгоритм создания эффекта эха

1.           i::=1;
2.           MaxValue::=MaxValue*256;
3.           i::=i+1;
4.           Если i≤(AudioData.nBlockAlign/AudioData.nChannels),то переход к п.2 иначе к п.5;
5.           MaxValue::=MaxValue/2 – 1;
6.           TempAudio.nChannels ::= AudioData.nChannels;
7.           TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
8.           TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
9.           DelaySmp := Round(Delay*AudioData.nSamplesPerSec/1000);
10.      Channel :: =0;
11.      Если Channel > (AudioData.nChannels-1),то переход к п.31 иначе к п.12;
12.      i ::= Start;
13.      Если i > (Start+Count-1), то переход к п.30 иначе к п.14;
14.      Прочитать Smp;
15.      SummSmp ::= Smp; Mult::=Volume;
16.      j ::= 1;
17.      Если j > Number, то переход к п.23 иначе к п.18;
18.      Если (i – Start) < (DelaySmp*j), то переход к п.19 иначе к п.20;
19.      Smp ::= 0;
20.      Прочитать Smp;
21.      SummSmp ::= SummSmp + Mult*Smp; Mult ::= Mult*Volume;
22.      j ::= j+1; переход к 17;
23.      Smp ::= SummSmp/(Number + 1);
24.      Если |Smp|>MaxValue, то переход к п.25 иначе к п.28;
25.      Если Smp<0, то переход к п.26 иначе к п.27;
26.      Smp ::= -MaxValue;
27.      Smp ::= MaxValue;
28.      Запись Smp в TempAudio;
29.      i ::= i+1; переход к п.13;
30.      Сhannel :: = Channel+1; переход к п.11;
31.      AudioData ::= TempAudio;
32.      Конец.

2.3.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры применения эффекта реверберации с различными параметрами.

2.3.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.4.        Описание алгоритма изменения темпа звука

2.4.1.      Назначение и характеристика алгоритма изменения темпа звука

Данный алгоритм применяется для замедления или ускорения скорости воспроизведения звукового сигнала.

2.4.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации.
При реализации алгоритма учитываются следующие параметры, которые подаются в качестве параметров на вход алгоритма: величина новой скорости воспроизведения в процентах от текущей (Ск).

2.4.3.      Результаты решения

В результате реализации алгоритма формируется новый массив значений времени T’, массив с амлитудами A остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.4.4.      Математическое описание алгоритма изменения темпа звука

Для получения выходного массива T’ используются следующие формулы:
T’₁ = T₁ * Ск/100;
T’₂ = T₂ * Ск/100;
…
T’_n = T_n * Ск/100.
Описание используемых обозначений приведено в п.2.4.2.

2.4.5.      Алгоритм изменения темпа звука

1.           Если (Speed=1)или(Speed=0), то переход к п.31 иначе к п.2;
2.           TempAudio.nChannels := AudioData.nChannels;
3.           TempAudio.nSamplesPerSec := AudioData.nSamplesPerSec;
4.           TempAudio.nBitsPerSample := AudioData.nBitsPerSample;
5.           TempAudio.nBlockAlign := AudioData.nBlockAlign;
6.           NewCount := Round(Count/Speed);
7.           Если Speed > 1 , то переход к п.8 иначе к п.14;
8.           i ::= NewCount; Interval ::= Speed;
9.           AudioData.Data.Position ::= Start*AudioData.nBlockAlign;
10.      Если i <> 0 , то переход к п.11 иначе к п.14;
11.      Прочитать Buf из AudioData; Записать Buf в TempAudio;
12.      AudioData.Data.Position ::= AudioData.Data.Position - AudioData.nBlockAlign + ]Interval[*AudioData.nBlockAlign;
13.      Interval := Interval-]Interval[+Speed; i ::= i – 1; переход к п.10;
14.      Speed ::= 1/Speed;
15.      Channel ::= 0;
16.      Если Channel > (AudioData.nChannels-1), то переход к п.31 иначе к п.17;
17.      i ::= 0; j ::= 0; Interval ::= Speed;
18.      Если i<>Count, то переход к п.19 иначе к п.30;
19.      Прочитать Smp1;
20.      Если (i+1) <> Count, то переход к п.21 иначе к п.22;
21.      Прочитать Smp2;
22.      Smp2 ::= Smp1;
23.      k ::= ]Interval[;
24.      n::=0;
25.      Если n > (k-1), то переход к п.28 иначе к п.26;
26.      Записать в TempAudio (Smp1+(Smp2-Smp1)/k*n);
27.      n ::= n+1; переход к п.25;
28.      Interval ::= Interval - ]Interval[ + Speed;
29.      i :: = i+1; j ::= j+k; переход к п.18;
30.      переход к п.16;
31.      Конец.

2.4.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры изменения темпа звука: увеличение и уменьшение скорости его воспроизведения.

2.4.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Speed – новая скорость звукового сигнала в процентах от текущей;
TempAudio – получаемая совокупность значений амплитуд и времен;
Smp1, Smp2 – переменные для хранения амплитуд;
Channel – количество каналов;
Interval – текущий обрабатываемый временной интервал;
Count – текущее количество отметок времени;
NewCount – новое количество отметок времени.

2.5.        Описание алгоритма изменения громкости звука

2.5.1.                Назначение и характеристика алгоритма изменения громкости звука

Данный алгоритм применяется для увеличения или уменьшения громкости (амплитуды) звукового сигнала.

2.5.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации.
При реализации алгоритма учитываются следующие параметры, которые подаются в качестве параметров на вход алгоритма: величина новой громкости звукового сигнала в процентах от текущей (Гр).

2.5.3.      Результаты решения

В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.5.4.      Математическое описание алгоритма изменения громкости звука

Для получения выходного массива A’ используются следующие формулы:
A’₁ = А₁ * Гр/100;
A’₂ = А₂ * Гр/100;
…
A’_n = A_n * Гр/100.
Описание используемых обозначений приведено в п.2.5.2.

2.5.5.      Алгоритм изменения громкости звука

1.                     MaxValue ::= 1;
2.                     i ::= 0;
3.                     Если i > (AudioData.nBlockAlign/AudioData.nChannels), то переход к п.5 иначе к п.4;
4.                     MaxValue ::= MaxValue * 256;
5.                     MaxValue ::= MaxValue/2 – 1;
6.                     Channel ::=0;
7.                     Если Channel > (AudioData.nChannels – 1), то переход к п.19 иначе к п.8;
8.                     Volume ::= 1; i ::= Start;
9.                     Если i > (Start+Count-1), то переход к п.18 иначе к п.10;
10.                Прочитать Value из файла;
11.                Value ::= ]Value*Volume[;
12.                Если |Value|>MaxValue, то переход к п.13 иначе к п.16;
13.                Если Value<0, то переход к п.14 иначе к п.15;
14.                Value ::= -MaxValue; переход к п.16;
15.                Value ::= MaxValue;
16.                Записать Value в файл;
17.                i ::= i+1; переход к п.9;
18.                Channel ::= Channel+1; переход к п.7;
19.                Конец.

2.5.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры изменения громкости звука: увеличение и уменьшение амплитуды звукового сигнала.

2.5.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.6.        Описание алгоритма создания эффекта возрастающей громкости

2.6.1.                Назначение и характеристика алгоритма изменения громкости звука

Данный алгоритм применяется для плавного увеличения громкости от нулевого уровня в начале фрагмента до максимального в конце.

2.6.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации.

2.6.3.      Результаты решения

В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.6.4.                Математическое описание алгоритма создания эффекта возрастающей громкости

Для получения выходного массива A’ используются следующие формулы:
A’₁ = А₁ * 1/n;
A’₂ = А₂ * 2/n;
…
A’_n = A_n.
Описание используемых обозначений приведено в п.2.6.2.

2.6.5.      Алгоритм создания эффекта возрастающей громкости

1.                     MaxValue ::= 1;
2.                     i ::= 0;
3.                     Если i > (AudioData.nBlockAlign/AudioData.nChannels), то переход к п.5 иначе к п.4;
4.                     MaxValue ::= MaxValue * 256;
5.                     MaxValue ::= MaxValue/2 – 1; FinalVolume ::= Volume;
6.                     Channel ::=0;
7.                     Если Channel > (AudioData.nChannels – 1), то переход к п.20 иначе к п.8;
8.                     Volume ::= 1; i ::= Start;
9.                     Если i > (Start+Count-1), то переход к п.19 иначе к п.10;
10.                Прочитать Value из файла;
11.                Value ::= ]Value*Volume[;
12.                Если |Value|>MaxValue, то переход к п.13 иначе к п.16;
13.                Если Value<0, то переход к п.14 иначе к п.15;
14.                Value ::= -MaxValue; переход к п.16;
15.                Value ::= MaxValue;
16.                Записать Value в файл;
17.                Volume ::= Volume + FinalVolume/Count;
18.                i ::= i+1; переход к п.9;
19.                Channel ::= Channel+1; переход к п.7;
20.                Конец.

2.6.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры применения эффекта возрастающей громкости к звуковому сигналу.

2.6.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.7.        Описание алгоритма создания эффекта затухающей громкости

2.7.1.                Назначение и характеристика алгоритма создания эффекта затухающей громкости

Данный алгоритм применяется для плавного уменьшения громкости от максимального уровня в начале фрагмента до нулевого в конце.

2.7.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации.

2.7.3.      Результаты решения

В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.7.4.  Математическое описание алгоритма создания эффекта затухающей громкости

Для получения выходного массива A’ используются следующие формулы:
n – количество временных интервалов;
A’₁ = А₁ * n/n;
A’₂ = А₂ * (n-1)/n;
…
A’_n-1 = A_n-1 * 2/n;
A’_n = A_n * 1/n.
Описание используемых обозначений приведено в п.2.7.2.

2.7.5.      Алгоритм создания эффекта затухающей громкости

1.                     MaxValue ::= 1;
2.                     i ::= 0;
3.                     Если i > (AudioData.nBlockAlign/AudioData.nChannels), то переход к п.5 иначе к п.4;
4.                     MaxValue ::= MaxValue * 256;
5.                     MaxValue ::= MaxValue/2 – 1; FinalVolume ::= Volume;
6.                     Channel ::=0;
7.                     Если Channel > (AudioData.nChannels – 1), то переход к п.20 иначе к п.8;
8.                     Volume ::= 1; i ::= Start;
9.                     Если i > (Start+Count-1), то переход к п.19 иначе к п.10;
10.                Прочитать Value из файла;
11.                Value ::= ]Value*Volume[;
12.                Если |Value|>MaxValue, то переход к п.13 иначе к п.16;
13.                Если Value<0, то переход к п.14 иначе к п.15;
14.                Value ::= -MaxValue; переход к п.16;
15.                Value ::= MaxValue;
16.                Записать Value в файл;
17.                Volume ::= Volume + (FinalVolume-1)/Count;
18.                i ::= i+1; переход к п.9;
19.                Channel ::= Channel+1; переход к п.7;
20.                Конец.

2.7.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры применения эффекта затухающей громкости к звуковому сигналу различных форм.

2.7.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.8.        Описание алгоритма обращения звукового сигнала

2.8.1.                Назначение и характеристика алгоритма создания эффекта затухающей громкости

Данный алгоритм применяется для обращения воспроизведения звукового сигнала.

2.8.2.      Используемая информация

При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A₁,A₂,…,A_n} – массив амплитуд звукового сигнала;
T = {T₁,T₂,…,T_n} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
T_i – T_i-1 определяется частотой дискретизации.

2.8.3.      Результаты решения

В результате реализации алгоритма формируются новые массивы значений амплитуд A’ и времени T’. Структура выходного файла при этом соответствует описанной в п.2.1.2.

2.8.4.                Математическое описание алгоритма обращения звукового сигнала

Для получения выходных массивов A’ и Т’ используются следующие формулы:
A’₁ = А_n;
A’₂ = А_n-1;
…
A’_n-1 = A₂;
A’_n = A₁;
T’₁ = А_n;
T’₂ = А_n-1;
…
T’_n-1 = A₂;
T’_n = A₁.
Описание используемых обозначений приведено в п.2.8.2.

2.8.5.      Алгоритм обращения звукового сигнала

1.    AbsStart ::= Start*AudioData.nBlockAlign;
2.    AbsCount ::= Count*AudioData.nBlockAlign;
3.    AbsFinish ::= AbsStart+AbsCount; i ::= AbsFinish;
4.    Если (i-AbsStart)>=(MaxSizeOfBuffer), то переход к п.5 иначе к п.6;
5.    BufferStart := i – MaxSizeOfBuffer; переход к п.7;
6.    BufferStart := AbsStart;
7.    AudioData.Data.Position := BufferStart; Прочитать знаение амплитуды в Buf;
8.    Если i > BufferStart, то переход к п.9 иначе к п.11;
9.    i := i - AudioData.nBlockAlign; AudioData.Data.Position := i;
10.                      Прочитать Buf из AudioData; Записать Buf в TempAudio; переход к п.8;
11.                      Если i = AbsStart, то переход к п.12 иначе к п.4;
12.                      AudioData.Data.Position := AbsStart; TempAudio.Data.Position := 0;
13.                      i ::= 1;
14.                      Если I > Count, то переход к п.17 иначе к п.15;
15.                      Прочитать Buf из TempAudio; Записать Buf в AudioData;
16.                      i ::= i+1; переход к п.14;
17.                      Конец.

2.8.6.      Требования к контрольному примеру

Контрольный пример должен содержать примеры применения обращения звукового сигнала различных форм.

2.8.7.      Список условных обозначений

AudioData – совокупность значений амплитуд и времен;
Start – указатель на место в массиве данных,с которого начинать обработку;
Count – количество элементов массивов, которые необходимо обработать;
Number – количество отражений;
Delay – время между отражениями;
Volume – громкость отклика относительно предыдущего;
TempAudio – получаемая совокупность значений амплитуд и времен;
SmpBuf – хранит выборку аудиоданных;
Mult – коэффициент для получения значения амплитуды отражения;
Smp – текущая амплитуда;
Channel – количество каналов;
MaxValue – макс. значение амплитуды в обрабатываемом фрагменте;
DelaySmp = T_i – T_i-1.

2.9.        Описание подпрограммы «Reverberation»

2.9.1.      Вводная часть

Подпрограмма Reverberation служит для применения эффекта реверберации к указанному фрагменту звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.9.2.      Функциональное назначение

Подпрограмма Reverberation предназначена для реализации алгоритма создания эффекта реверберации.

2.9.3.      Описание информации

Звуковой сигнал, записанный в файле, представлен следующим классом:
TAudioData = class(TObject)
 public
 nChannels: Word;
 nSamplesPerSec: LongWord;
 nBitsPerSample: Word;
 nBlockAlign: Word;
 Data: TFile;
 constructor Create;
 destructor Destroy;
 procedure Calculate_nBlockAlign;
 procedure ReadSample(Number, Channel: LongInt; var Value: Integer);
 procedure WriteSample(Number, Channel: LongInt; Value: Integer);
 private
 Name: String;
 end;
Описание полей класса представления звукового сигнала:
nChannels – число каналов;
nSamplesPerSecond – частота дискретизации;
nBitsPerSample – битрейт;
nBlockAlign – блок выравнивания (число каналов х разрядность);
Data – звуковые данные;
Name – имя файла.
TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен.
Описание используемых в подпрограмме переменных представлено в табл.2.2.
Таблица 2.2
Переменные, используемые в подпрограмме «Reverberation»

Имена переменных	Тип	Описание
i, j, k	integer	Переменные-счетчики
DelaySmp	Cardinal	Равно Ti – Ti-1
SmpBuf	array[0..64] of Int64	Хранит выборку аудио-данных
Mult	Real	Коэффициент для получения значения амплитуды отражения
Smp	Integer	Текущая амплитуда
Channel	Word	Количество каналов
MaxValue	Cardinal	Максимальное значение амплитуды в обрабатываемом фрагменте

Описание входных данных подпрограммы представлено в табл.2.3.
Таблица 2.3
Входные данные подпрограммы «Reverberation»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокуп-ность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относи-тельно стартовой
Number	Cardinal	Количество отражений
Delay	Cardinal	Время между отражениями
Volume	Real	Громкость отражения относитель-но предыдущего

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с эффектом реверберации.

2.9.4.      Используемые программы

В подпрограмме используются следующие подпрограммы:
1.     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2.     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.9.5.  Схема подпрограммы «Reverberation»

Схема подпрограммы «Reverberation» приведена на рис. 2.17.

Нет

Нет

Нет

Нет

Нет

Нет

Да

Да

Да

Да

Да

Да

Да

Нет

Схема подпрограммы «Reverberation»

Рис. 2.17

2.10.   Описание подпрограммы «Echo»

2.10.1. Вводная часть

Подпрограмма Echo служит для применения эффекта эха к указанному фрагменту звукового сигнала, записанного в файле. Текст программы приведен в приложении 1.

2.10.2. Функциональное назначение

Подпрограмма Echo предназначена для реализации алгоритма создания эффекта эха.

2.10.3. Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. Описание используемых в подпрограмме переменных представлено в табл.2.4.
Таблица 2.4
Переменные, используемые в подпрограмме «Echo»

Имена переменных	Тип	Описание
i, j, k	integer	Переменные-счетчики
DelaySmp	Cardinal	Равно Ti – Ti-1
SmpBuf	array[0..64] of Int64	Хранит выборку аудио-данных
Mult	Real	Коэффициент для полу-чения значения амплиту-ды отражения
Smp	Integer	Текущая амплитуда
Channel	Word	Количество каналов
MaxValue	Cardinal	Макс. значение ампли-туды в обрабатываемом фрагменте

Описание входных данных подпрограммы представлено в табл.2.5.
Таблица 2.5
Входные данные подпрограммы «Echo»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой
Number	Cardinal	Количество откликов
Delay	Cardinal	Время между откликами
Volume	Real	Громкость отклика отно-сительно предыду-щего

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с эффектом эха.

2.10.4. Используемые подпрограммы

В подпрограмме используются следующие подпрограммы:
1.     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2.     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.10.5. Схема подпрограммы «Echo»

Схема подпрограммы «Echo» приведена на рис. 2.18.

Нет

Да

Да

Нет

Нет

Нет

Нет

Да

Да

Да

Нет

Да

Схема подпрограммы «Echo»

Рис. 2.18

2.11.   Описание подпрограммы «SetSpeedOfAudio»

2.11.1. Вводная часть

Подпрограмма SetSpeedOfAudio служит для измения темпа (скорости) указанного фрагмента звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.11.2. Функциональное назначение

Подпрограмма SetSpeedOfAudio предназначена для реализации алгоритма изменения темпа звука.

2.11.3. Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. . Описание используемых в подпрограмме переменных представлено в табл.2.6.
Таблица 2.6
Переменные, используемые в подпрограмме «SetSpeedOfAudio»

Имена переменных	Тип	Описание
i, j, k, n, NewCount	integer	Переменные-счетчики
Buf	Int64	Выравнивание (число каналов х разрядность)
Interval	Real	Интервал времени между двумя значениями амплитуд
Smp1, Smp2	Integer	Значения амплитуд
Channel	Byte	Количество каналов

Описание входных данных подпрограммы представлено в табл.2.7.
Таблица 2.7
Входные данные подпрограммы «SetSpeedOfAudio»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой
Speed	Real	Новая скорость звуко-вого сигнала

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с измененным темпом.

2.11.4. Используемые программы

В подпрограмме используются следующие подпрограммы:
1)     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2)     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.11.5. Схема подпрограммы «SetSpeedOfAudio»

Схема подпрограммы «SetSpeedOfAudio» приведена на рис. 2.19.

Нет

Нет

Нет

Нет

Да

Да

Да

Да

Да

Нет

Схема подпрограммы «SetSpeedOfAudio»

Рис. 2.19

2.12.           Описание подпрограммы «SetVolumeOfAudio»

2.12.1.   Вводная часть

Подпрограмма SetVolumeOfAudio служит для измения уровня громкости указанного фрагмента звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.12.2. Функциональное назначение

Подпрограмма SetVolumeOfAudio предназначена для реализации алгоритма изменения общего уровня громкости звука.

2.12.3. Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. . Описание используемых в подпрограмме переменных представлено в табл.2.8.
Таблица 2.8
Переменные, используемые в подпрограмме «SetVolumeOfAudio»

Имена переменных	Тип	Описание
i	integer	Переменная-счетчик
MaxValue	Cardinal	Макс. значение ампли-туды в обрабатываемом фрагменте
Value	Cardinal	Текущее значение амплитуды
Channel	Word	Количество каналов

Описание входных данных подпрограммы представлено в табл.2.9.
Таблица 2.9
Входные данные подпрограммы «SetVolumeOfAudio»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой
Volume	Real	Новая громкость звуко-вого сигнала

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с измененным уровнем громкости.

2.12.4. Используемые программы

В подпрограмме используются следующие подпрограммы:
1)     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2)     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.12.5. Схема подпрограммы «SetVolumeOfAudio»

Схема подпрограммы «SetVolumeOfAudio» приведена на рис. 2.20.

Нет

Нет

Нет

Да

Да

Да

Нет

Да

Схема подпрограммы «SetVolumeOfAudio»

Рис. 2.20

2.13.   Описание подпрограммы «ReChangeVolumeOfAudio»

2.13.1. Вводная часть

Подпрограмма ReChangeVolumeOfAudio служит для применения эффекта возрастающей громкости к указанному фрагменту звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.13.2. Функциональное назначение

Подпрограмма ReChangeVolumeOfAudio предназначена для реализации алгоритма создания эффекта возрастающей громкости.

2.13.3. Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. Описание используемых в подпрограмме переменных представлено в табл.2.10.
Таблица 2.10
Переменные, используемые в подпрограмме «ReChangeVolumeOfAudio»

Имена переменных	Тип	Описание
i	integer	Переменная-счетчик
MaxValue	Cardinal	Макс. значение ампли-туды в обрабатываемом фрагменте
Value	Cardinal	Текущее значение амплитуды
Channel	Word	Количество каналов
FinalVolume	Real	Значение амплитуды в конце обрабатываемого фрагмента

Описание входных данных подпрограммы представлено в табл.2.11.
Таблица 2.11
Входные данные подпрограммы «ReChangeVolumeOfAudio»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с примененным эффектом возрастающей громкости.

2.13.4. Используемые программы

В подпрограмме используются следующие подпрограммы:
1)     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2)     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.13.5. Схема подпрограммы «ReChangeVolumeOfAudio»

Схема подпрограммы «ReChangeVolumeOfAudio» приведена на рис. 2.21.

Нет

Да

Да

Да

Нет

Да

Нет

Нет

Схема подпрограммы «ReChangeVolumeOfAudio»

Рис. 2.21

2.14.           Описание подпрограммы «ChangeVolumeOfAudio»

2.14.1.   Вводная часть

Подпрограмма ChangeVolumeOfAudio служит для применения эффекта затухающей громкости к указанному фрагменту звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.14.2. Функциональное назначение

Подпрограмма ChangeVolumeOfAudio предназначена для реализации алгоритма создания эффекта затухающей громкости.

2.14.3. Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. . Описание используемых в подпрограмме переменных представлено в табл.2.12.
Таблица 2.12
Переменные, используемые в подпрограмме «ChangeVolumeOfAudio»

Имена переменных	Тип	Описание
i	integer	Переменная-счетчик
MaxValue	Cardinal	Макс. значение ампли-туды в обрабатываемом фрагменте
Value	Cardinal	Текущее значение амплитуды
Channel	Word	Количество каналов
FinalVolume	Real	Значение амплитуды в начале обрабатываемого фрагмента

Описание входных данных подпрограммы представлено в табл.2.13.
Таблица 2.13
Входные данные подпрограммы «ChangeVolumeOfAudio»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с примененным эффектом затухающей громкости.

2.14.4. Используемые программы

В подпрограмме используются следующие подпрограммы:
1)     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2)     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.14.5. Схема подпрограммы «ChangeVolumeOfAudio»

Схема подпрограммы «ChangeVolumeOfAudio» приведена на рис. 2.22.

Да

Да

Да

Нет

Да

Нет

Нет

Нет

Схема подпрограммы «ChangeVolumeOfAudio»

Рис. 2.22

2.15.           Описание подпрограммы «ReverseAudio»

2.15.1.   Вводная часть

Подпрограмма ReverseAudio служит для применения обращения указанного фрагмента звукового сигнала, записанного в файле. Текст подпрограммы приведен в приложении 1.

2.15.2.   Функциональное назначение

Подпрограмма ReverseAudio предназначена для реализации алгоритма обращения звукового сигнала.

2.15.3.   Описание информации

TempAudio: TAudioData; – получаемая совокупность значений амплитуд и времен. . Описание используемых в подпрограмме переменных представлено в табл.2.14.
Таблица 2.14
Переменные, используемые в подпрограмме «ReverseAudio»

Имена переменных	Тип	Описание
i	integer	Переменная-счетчик
Buf	Int64	Текущее значение амплитуды
AbsStart	Cardinal	Абсолютная позиция начала обработки
AbsCount	Cardinal	Абсолютное количество позиций для обработки
AbsFinish	Cardinal	Абсолютная позиция конца обработки

Описание входных данных подпрограммы представлено в табл.2.15.
Таблица 2.15
Входные данные подпрограммы «ReverseAudio»

Имена переменных	Тип	Описание
AudioData	TAudioData	Передаваемая исходная совокупность значений амплитуд и времен
Start	Cardinal	Стартовая позиция, с которой необходимо начать обработку
Count	Cardinal	Количество позиций, которые необходимо обработать относительно стартовой

Выходные данные подпрограммы:
AudioData – измененная совокупность значений амплитуд и времен с обращенным звуковым сигналом.

2.15.4. Используемые программы

В подпрограмме используются следующие подпрограммы:
1)     ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2)     WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.

2.15.5. Схема подпрограммы «ReverseAudio»

Схема подпрограммы «ReverseAudio» приведена на рис. 2.23.

Нет

Да

Нет

Да

Нет

Да

Схема подпрограммы «ReverseAudio»

Рис. 2.23

2.16.           Описание контрольного примера

2.16.1.   Назначение

Основной целью работы программы является изменение параметров звуковых сигналов, их структуры и применение различных звуковых эффектов для получения необходимых характеристик звучания. Результатом работы программы является измененный звуковой сигнал, записанный в файле. Контрольный пример должен содержать исходный звуковой сигнала, записанный в файле одного из следующих форматов: Microsoft RIFF/WAVE (файлы с расширением wav), MP3 (файлы с расширением mp3), Electronic music (файлы с расширением em1).

2.16.2.   Исходные данные

На рис. 2.24 и рис. 2.25 приведены изображения исходных звуковых сигналов. К первому предполагается применить звуковые эффекты (реверберация, эхо), изменить параметры (частота дискретизации, битрейт, число каналов, общий уровень громкости, темп) и отредактировать структуру (удаление, копирование, обращение части сигнала). Ко второму предполагается применить эффекты возрастающей и затухающей громкости. Данные звуковые сигналы получены путем записи их через микрофон. Файлы сохранены в формате Microsoft RIFF/WAVE, поэтому пригодны для тестирования.

Исходные звуковые сигналы

Рис. 2.24

Рис. 2.25

Параметры исходных звуковых сигналов, записанных в файле:
Первый звуковой сигнал:
Частота дискретизации: 44100 Hz;
Битрейт: 16;
Число каналов: 2.
Второй звуковой сигнал:
Частота дискретизации: 22050 Hz;
Битрейт: 16;
Число каналов: 2.

2.16.3. Контрольный пример

Применение эффекта эха.
Установленные параметры эффекта: 2 отклика, 75% громкость, задержка между откликами 400 мс. Результат применения эффекта к исходному сигналу показан на рис.2.26.
Эффект эха

Рис.2.26
Применение эффекта реверберации.
Установленные параметры эффекта: 2 отражения, 70% громкость, задержка между отражениями 62 мс. Результат применения эффекта к исходному сигналу показан на рис.2.27.
Эффект реверберации

Рис.2.27

Уменьшение темпа.
Установленные параметры эффекта: уменьшение темпа в 2 раза. Результат применения к исходному сигналу показан на рис.2.28.
Уменьшение темпа

Рис.2.28
Увеличение темпа в два раза.
Установленные параметры эффекта: увеличение темпа в 2 раза. Результат применения к исходному сигналу показан на рис.2.29.
Увеличение темпа

Рис.2.29
Увеличение общего уровня громкости.
Установленные параметры эффекта: увеличение громкости в 2 раза. Результат применения к исходному сигналу показан на рис.2.30.
Увеличение громкости

Рис.2.30
Уменьшение общего уровня громкости в два раза:
Установленные параметры эффекта: уменьшение громкости в 2 раза. Результат применения к исходному сигналу показан на рис.2.31.
Уменьшение громкости

Рис.2.31
Применение эффекта возрастающей громкости:
Результат применения эффекта к исходному сигналу показан на рис.2.32.
Эффект возрастающей громкости

Рис.2.32
Применение эффекта затухающей громкости:
Результат применения эффекта к исходному сигналу показан на рис.2.33.
Эффект затухающей громкости

Рис.2.33
Обращение звука:
Результат применения к исходному сигналу показан на рис.2.34.
Обращение исходного сигнала

Рис.2.34
Удаление части сигнала:
Была удалена первая часть исходного звукового сигнала. Результат применения показа на рис.2.35.
Удаление части сигнала

Рис.2.35
Копирование части сигнала (скопирована в конец вторая часть звукового сигнала):
Была скопирована в конец вторая часть исходного звукового сигнала. Результат применения показан на рис.2.36.
Копирование части сигнала

Рис.2.36
Были изменены параметры:
частота дискретизации: 22050 Hz;
битрейт: 8;
число каналов: 1.

2.16.4.   Результаты тестирования работы подсистемы обработки и фильтрации звукового сигнала

Для испытания программного обеспечения подсистемы обработки и фильтрации сигнала на вход были поданы два звуковых сигнала формата Microsoft RIFF/WAVE. Испытания проводились согласно руководству программиста, приведенному в приложении 2, и руководству оператора, приведенному в приложении 3. В результате были получены измененные звуковые сигналы с заданными характеристиками звучания. Измененные звуковые сигналы были сохранены в формате Microsoft RIFF/WAVE.
Тестирование показало, что разработанное программное обеспечение способно анализировать подаваемый на вход звуковой сигнал, определять и изменять его параметры, редактировать структуру звукового сигнала и применять различные эффекты для достижения необходимых характеристик звучания.

 

3.                ОРГАНИЗАЦИОННО-ЭКОНОМИЧЕСКАЯ ЧАСТЬ

                   Обоснование необходимости разработки подсистемы обработки и фильтрации сигнала

Подсистема обработки и фильтрации сигнала является неотъемлимой частью системы обработки аудиоинформации, предназначенной для редактирования и кодирования звуковых сигналов, записанных в файлах. Разрабатываемая система носит исследовательский характер и предназначена для поиска и отладки наиболее эффективных алгоритмов обработки звуковой информации. Реализация подсистемы позволит в значительной степени облегчить труд программиста-исследователя посредством автоматизации процесса обработки звуковых сигналов.
Подсистема обработки и фильтрации звуковых сигналов позволит редактировать основные параметры цифрового звука, модифицировать их структуру, применить различные эффекты для достижения необходимых характеристик звучания.
Уменьшение размера файлов, содержащих звуковую информацию, имеет большое значение как при их хранении, так и при пересылке по каналам связи. Таким образом, разработка системы позволит, помимо выполнения операций редактирования и преобразования звуковых сигналов, сэкономить на загрузке устройств хранения информации и снизить нагрузку на каналы связи.

                         Расчет затрат на разработку подсистемы обработки и фильтрации сигнала

Для определения величины расходов на создание подсистемы, используем прямой метод калькуляции.
Расчет сметы затрат осуществляется по следующим статьям
-            расходы на основные и вспомогательные материалы;
-            расходы на оплату труда исполнителей;
-            расходы на социальные программы;
-            расходы на содержание и амортизацию основных фондов;
-            накладные расходы;
-            прочие расходы.
К статье «Расходы на основные и вспомогательные материалы» относятся покупные изделия, необходимые для выполнения работы, перечисленные в табл. 3.1.
Таблица 3.1
Расходы на основные и вспомогательные материалы
Оклад инженера-программиста в период разработки составлял 3000 р. в месяц. Продолжительность разработки 3 месяца.

ЗП = ЗПМ*ПМ

(3.1)

З_П = 3000 * 3 = 9000 руб.
К окладу начисляется премия. Процент премиальных составил 15% в месяц.

ЗП,% = ЗП*1.15

(3.2)

З_П,% = 9000 * 1.15 = 10350 руб.
Плановые накопления в фонд резерва отпусков (З_Д) рассчитывается в размере 10% от тарифной платы:

ЗПД = ЗП * 0.10

(3.3)

ЗП_Д = 9000 * 0.10 = 900 руб.
В расходы на оплату труда необходимо включить уральский коэффициент (15%). Районный коэффициент рассчитывается от оклада вместе с премиальными и дополнительной заработной платой.
К_УР = (9000 + 1350) * 0.15 = 1552.50 руб.
Следовательно, расходы на оплату труда с учетом зонального коэффициента составят:

ЗПОСН = ЗП,% + ЗПД + КУР

(3.4)

ЗП_ОСН = 10350 + 900 + 1552.50 = 12802.50 руб.
Сумма налоговой базы не превышает 280000 руб., поэтому статья «Расходы на социальные налоги» включает в себя отчисления в пенсионный фонд (20%), на медицинское (3.1%) и социальное страхование (2.9%), отчисления в фонд страхования от несчастных случаев (0.2%), что составляет 26.2% /33/. Отчисления производятся от общих расходов на оплату труда и сумма отчислений составляет:

СОТЧ = ЗПОСН * 0.262

(3.5)

С_ОТЧ = 12802.50 * 0.262 = 3354.26 руб.
Статья «Расходы на амортизацию и эксплуатацию ВТ» включает расходы, связанные с эксплуатацией вычислительной техники. Стоимость одного машинного часа рассчитывается по формуле:

АЧ = СИСП / (ЧМ * КЧ) ,

(3.6)

где А_Ч – аренда за час использования;
С_ИСП - общая стоимость использования ЭВМ;
Ч_М – число месяцев в году;
К_Ч - количество рабочих часов в месяце.

СИСП = АКОМП + ЗПОБСЛ + СЗЧ + СЭЛ + АПО ,

(3.7)

где А_КОМП – амортизация компьютера за год эксплуатации;
ЗП_ОБСЛ – расходы на оплату труда обслуживающего персонала за год эксплуатации;
ЗП_ОБСЛ = 1500 руб/мес.;
С_ЗЧ – стоимость запчастей для компьютера за год эксплуатации;
С_ЗЧ = 200 руб/год;
С_ЭЛ – стоимость израсходованной электроэнергии за год эксплуатации;
С_ЭЛ = 2400 руб/год;
А_ПО – годовая амортизация программного обеспечения.

АКОМП = СКОМП / СПИ ,

(3.8)

где С_КОМП – стоимость компьютера;
С_ПИ – срок полезного использования (в годах).
А_КОМП = 30000 / 5 = 6000 руб.

АПО = СТПО / СПИ ,

(3.9)

где СТ_ПО – стоимость программного обеспечения;
С_ПИ – срок полезного использования (в годах).
А_ПО = 5800 / 5 = 1160 руб.
С_ИСП = 6000 + 1500*12 + 200 + 2400 + 1160 = 27760 руб.
А_Ч = 27760 / (12 * 176) = 13.14 руб
ЭВМ использовалась на этапах проектирования (41 час), программирования (79 часов), отладки (551 часов) и документирования (299 часов), т.е. всего 970 часов. Следовательно, сумма расходов на содержание ВТ составит:

САР = Эч * Ач ,

(3.10)

С_АР = 970 * 13.14 = 12745,80 руб.
Статья «Прочие расходы» содержит расходы, неучтенные в предыдущих статьях (до 50 % от расходов на оплату труда) :

ПР = ЗПОСН * 0.5 ,

(3.11)

П_Р = 12802.50 * 0.5 = 6401.25 руб.
Статья «Накладные расходы» включает в себя расходы по управлению (заработная плата управления, расходы на все виды командировок управленческого аппарата), содержание пожарной и сторожевой охраны, содержание и текущий ремонт зданий, сооружений, инвентаря; содержание персонала, не относящегося к аппарату управления; расходы по изобретательству и рационализации; по подготовке кадров; расходы на содержание ВЦ; канцелярские, почтово-телеграфные расходы и др. общехозяйственные расходы; непроизводственные расходы. Накладные расходы составляют 130% от расходов на оплату труда, таким образом, получаем:

НР = ЗПОСН * 1.3 ,

(3.12)

Н_Р = 12802.50 * 1.3 = 16643,25 руб.
Сумма затрат на разработку подсистемы в целом составила 58670.32 руб. Табл. 3.2 отражает затраты по статьям и структуру этих затрат в общей сумме.
Таблица 3.2
Смета затрат на разработку подсистемы
 
Округлим полученную сумму до тысяч для учета непредвиденных затрат. Получим, что сумма затрат на разработку системы составит 53000 руб.
Структура затрат на разработку ПО приведена на рис. 3.1.
Структура затрат на разработку подсистемы обработки и фильтрации сигнала

Рис. 3.1

4. ЭКОЛОГИЧНОСТЬ И БЕЗОПАСНОСТЬ ПРОЕКТА

4.1. Анализ опасных и вредных факторов, возникающих при эксплуатации компьютера

Во время работы за ЭВМ часто возникают ситуации, в которых оператор ЭВМ должен за короткий срок принять правильное решение. Для успешного труда в таких условиях необходима рационально организованная среда, ограждающая работника от воздействия посторонних раздражителей, которыми могут быть мрачная окраска устройств ЭВМ и помещения ВЦ, неудобное расположение клавиш управления, сигнализации и т.п.
Поэтому всеми средствами необходимо снижать утомление и напряжение оператора ЭВМ, создавая обстановку производственного комфорта.
Все работники ВЦ в настоящее время сталкиваются с воздействием таких опасных и вредных факторов как повышенный уровень шума, температура внешней среды, рассчитанная на нормальное функционирование техники, а не человека, отсутствие или недостаток естественного света, излучение мониторов, статическое электричество и др.
Особенности характера и режима труда, значительное умственное напряжение (особенно для разработчиков) и другие нагрузки приводят к изменению у работников ВЦ функционального состояния центральной нервной системы, нервно-мышечного аппарата рук (при работе с клавиатурой и другими устройствами ручного ввода информации). Длительный дискомфорт вызывает повышенное напряжение, обусловливает развитие общего утомления и снижение работоспособности.
При длительной работе за экраном дисплея отмечается выраженное напряжение зрительного аппарата с появлением жалоб на неудовлетворенность работой, головные боли, раздражительность, нарушение сна, усталость и болезненные ощущения в глазах, в пояснице, в области шеи, руках и др.
Многие сотрудники ВЦ связаны с воздействием таких психофизических факторов, как перенапряжение слуховых анализаторов, монотонность труда, эмоциональные перегрузки.

4.1.1. Выявление источников шума и вибрации

Шум рассматривают как звук, мешающий разговорной речи и негативно влияющий на здоровье человека. Действие шума не ограничивается воздействием только на органы слуха. Через нервные волокна шум передается в центральную и вегетативную нервные системы, а через них воздействует на внутренние органы, приводя к значительным изменениям в функциональном состоянии организма.
Наличие множественных источников постоянного шума на рабочем месте приводит к значительному снижению производительности труда, росту количества ошибок в работе операторов.
По происхождению шум делят на механический, аэродинамический и шум электрических машин. Для рабочих мест операторов характерно наличие всех видов шумов. Технические средства, например принтер, плоттер создают механический шум, установки кондиционирования — аэродинамический шум, преобразователи напряжения— электромагнитный.
В соответствии с ГОСТ 12.1.003-83 “Шум, общие требования безопасности” /7/ уровень шума на рабочем месте операторов не должен превышать 50дБ, а в помещениях, где работают инженерно-технические работники, осуществляющие лабораторный, аналитический и измерительный контроль — 60дБ.
Для снижения шума и вибрации в помещениях ВЦ оборудование, аппараты и приборы необходимо устанавливать на специальные фундаменты и амортизирующие прокладки, предусмотренные нормативными документами. Стены и потолки должны быть облицованы звукопоглощающим материалом, независимо от количества единиц установленного оборудования. В качестве звукопоглощающего материала должны использоваться специальные перфорированные плиты, панели и другой материал аналогичного назначения, а так же плотная хлопчатобумажная ткань, которой драпируются потолок и стены.
4.1.2. Выявление источников излучения, оказывающих влияние на программиста
Одним из наиболее опасных факторов, оказывающих влияние на организм, является ионизирующее излучение. Ионизирующие излучения, проникая через организм человека и проходя через биологическую ткань, вызывают в ней появление заряженных частиц – свободных электронов. Это сопровождается изменением структуры молекул, разрушением межмолекулярных связей, гибелью клеток. Изменение биохимического состава клеток и обменных процессов нарушает функции центральной нервной системы, что в свою очередь вызывает нарушение функций желез внутренней секреции: изменение сосудистой проницаемости и т.п.
Основным источником излучений при работе с персональным компьютером являются дисплей. Он генерируют несколько типов излучения, в том числе рентгеновское, радиочастотное, видимое и ультрафиолетовое. Максимальный уровень рентгеновского излучения на рабочем месте оператора ком­пьютера обычно не превышает 10 мкбэр/ч на расстоянии 5 см от поверхности экрана. Рентгеновское излучение уменьшается пропорционально квадрату расстояния до экрана. Интенсивность ультрафиолетового и ин­фра­красного излучений от экрана монитора лежит в пределах 10…100 мВт/м²_.
Экспериментальное исследование характера и интенсивности излучения дисплея с целью определить воздействие электромагнитных излучений на пользователя при длительной работе показало, что уровни облучения в ультрафиолетовой, инфракрасной и видимой областях спектра оказались ниже допустимых значений. Таким образом, считается, что интенсивность излучения экрана дисплея не превышает предельно допустимой дозы радиации и, следовательно, условия труда можно отнести к безопасным.
Для дополнительного снижения излучений реко­мен­дуется применять мониторы с пониженным уровнем излучения (MPR-II, TCO-92, TCO-99), устанавливать за­щитные экраны, которые поглощают до 100% ультрафиолетового излучения, ослабляют электростатическое поле на 99%, а также соб­людать регламентированные режи­мы труда и отдыха.

 

4.2. Электробезопасность при работе с компьютером

Электрические установки, к которым относится практически все оборудование ЭВМ, представляют для человека большую потенциальную опасность, так как в процессе эксплуатации или проведении профилактических работ человек может коснуться частей, находящихся под напряжением.
Любое воздействие тока может привести к электрической травме, то есть к повреждению организма, вызванному действием электрического тока или электрической дуги.
При рассмотрении вопроса обеспечения электробезопасности разработчика необходимо выделить три основных фактора:
- электроустановки рабочего места программиста;
- вспомогательное электрооборудование;
- окружающая среда помещения.
К электроустройствам рабочего места относятся: компьютер, видеомонитор, принтер. К вспомогательному оборудованию относятся лампы местного освещения, вентиляторы и другие электрические приборы. Электрооборудование, перечисленное выше, относится к установкам напряжением до 1000 В, исключение составляют лишь дисплей, электронно-лучевые трубки, которых имеют напряжение в несколько киловольт.
Окружающая среда помещений, в которых работает программист, воздействует на электрическую изоляцию приборов и устройств, электрическое сопротивление тела человека и может создавать условия для поражения электрическим током.
Помещения, оборудованные вычислительной техникой, как правило, относятся к категории помещений без повышенной опасности, так как:
- относительная влажность воздуха не превышает 75%;
- нет токопроводящей пыли;
- температура не превышает длительное время 30 °С;
- отсутствует возможность одновременного прикосновения человека с имеющим соединение с землей металлическими конструкциями;
- отсутствие возможности прикоснуться к токоведущим частям оборудования;
- нет токопроводящих полов.
Таким образом, для предотвращения электротравматизма пользователя необходимо соблюдать требования безопасности, как при работе с обычной бытовой техникой.

4.3. Организация рабочего места инженера-программиста

На инженера-программиста оказывают воздействие различные вредные и опасные факторы, которые отрицательно влияют на здоровье: излучение экрана монитора ПК, плохое проветривание и недостаточная освещенность помещений могут привести к заболеваниям организма различной степени тяжести.
Длительное нахождение человека в зоне вышеперечисленных воздействий может привести к профессиональному заболеванию, поэтому в данном разделе решается задача обеспечения безопасных условий труда инженера-программиста.
Главными элементами рабочего места программиста являются стол и кресло. Основным рабочим положением является положение сидя. Рабочая поза сидя вызывает минимальное утомление программиста. Рациональная планировка рабочего места предусматривает четкий порядок и постоянство размещения предметов, средств труда и документации. То, что требуется для выполнения работ чаще, расположено в зоне легкой досягаемости рабочего пространства. Моторное поле – пространство рабочего места, в котором могут осуществляться двигательные действия человека. Максимальная зона досягаемости рук – это часть моторного поля рабочего места, ограниченного дугами, описываемыми максимально вытянутыми руками при движении их в плечевом суставе. Оптимальная зона – часть моторного поля рабочего места, ограниченного дугами, описываемыми предплечьями при движении в локтевых суставах с опорой в точке локтя и с относительно неподвижным плечом. Схематично зоны досягаемости представлены на рис. 3.1.
Зоны досягаемости рук в горизонтальной плоскости

а – зона максимальной досягаемости;
б – зона досягаемости пальцев при вытянутой руке;
в – зона легкой досягаемости ладони;
г – оптимальное пространство для грубой ручной работы;
д – оптимальное пространство для тонкой ручной работы.
Рис.4.1
Оптимальное размещение предметов труда и документации в зонах досягаемости:
– дисплей размещается в зоне а (в центре);
– системный блок размещается в предусмотренной нише стола;
– клавиатура – в зоне г/д;
– “мышь” – в зоне в справа;
– сканер – в зоне а/б (слева);
– принтер – в зоне а (справа);
– документация: необходимая при работе – в зоне легкой досягаемости ладони – в; неиспользуемая постоянно – в выдвижных ящиках стола.
Схематично размещение основных и периферийных составляющих ПК представлено на рис. 4.2.
Размещение основных и периферийных составляющих ПК

Рис. 4.2
При компоновке рабочего места необходимо учитывать зоны досягаемости рук человека при расположении дисплеев, клавиатуры, системного блока и так далее. Высота рабочей поверхности стола должна регулироваться в пределах 680 – 800 мм, при отсутствии такой возможности высота рабочей поверхности стола должна составлять 725 мм.
Рабочий стол должен иметь пространство для постановки ног высотой не менее 600 мм, шириной не менее 500 мм, глубиной на уровне колен – не менее 450 мм и на уровне вытянутых ног – не менее 650 мм.
Экран видеомонитора должен находиться от глаз пользователя на оптимальном расстоянии 600 – 700 мм, но не ближе 500 мм с учетом размеров алфавитно-цифровых знаков и символов.

 

4.4. Требования к параметрам микроклимата помещения

Под метеорологическими условиями понимают сочетание температуры, относительной влажности, скорости движения и запыленности воздуха. Перечисленные параметры оказывают огромное влияние на функциональную деятельность человека, его самочувствие и здоровье и на надежность средств вычислительной техники. Эти микроклиматические параметры влияют как каждый в отдельности, так и в различных сочетаниях.
Температура воздуха является одним из основных параметров, характеризующих тепловое состояние микроклимата. Суммарное тепловыделение в помещении поступает от:
- ЭВМ;
- вспомогательного оборудования;
- приборов освещения;
- людей;
- внешних источников.
Наибольшее количество теплоты выделяют ЭВМ и вспомогательное оборудование. Средняя величина тепловыделения от компьютеров колеблется до 100 Вт/м². Тепловыделения от приборов освещения также велики. Удельная величина их составляет 35 Вт/м². При этом, чем больше уровень освещенности, тем выше удельные величины тепловыделений. Количество теплоты от обслуживающего персонала незначительно. Оно зависит от числа работающих в помещении, интенсивности работы, выполняемой человеком.
К внешним источникам поступления теплоты относят теплоту, поступающую через окна от солнечной радиации, приток теплоты через непрозрачные ограждения конструкций. Интенсивность этих источников зависит от расположения здания, ориентации по частям света, цветовой гаммы и прочее.
С целью создания нормальных условий труда программиста, ГОСТом 12.1.005-88 установлены оптимальные и допустимые значения всех параметров микроклимата. Оптимальные параметры при длительном и систематическом воздействии на организм человека обеспечивают сохранение нормального функционирования и теплового состояния организма, создают ощущение теплового комфорта и являются предпосылкой высокого уровня работоспособности. Допустимые параметры микроклимата могут вызвать приходящие и быстро нормализующиеся изменения организма, не выходящие за пределы физиологически приспособительных возможностей, не создающие нарушений состояния здоровья, но вызывающие дискомфортные теплоощущения, ухудшение самочувствия и понижение работоспособности. Оптимальные и допустимые значения основных микроклиматических параметров представлены в табл. 4.1.
Таблица 4.1
Параметры микроклимата производственных помещений

Параметры	Значения параметров
	оптимальные	допустимые
Температура	20-22 °С	17-22 °С
Относительная влажность	40-60 %	до 75%
Скорость движения воздуха	0,1 м/с	не более 0,3 м/с

Для обеспечения нормальных условий труда необходимо придерживаться вышеуказанных данных. В целях поддержания температуры и влажности воздуха в помещении можно использовать системы отопления, вентиляции и кондиционирования воздуха.
На исследуемом предприятии температура воздуха, влажность и скорость движения воздуха держится в рамках оптимальных параметров. Вредные вещества в воздухе рабочей зоны не превышают предельной допустимой концентрации.

4.5. Требования к освещению рабочих мест

К современному освещению помещений, где работают с вычислительной техникой, предъявляют высокие требования как гигиенического, так и технического характера. Правильно спроектированное и выполненное освещение обеспечивает высокий уровень работоспособности, оказывает положительное психологическое воздействие, способствует повышению производительности труда. Условия деятельности пользователя в системе "человек-машина" связаны с явным преобладанием зрительной информации – до 90% общего объема.
В помещениях с компьютерной техникой применяется совмещенная система освещения. К таким системам предъявляют следующие требования:
- соответствие уровня освещенности рабочих мест характеру выполняе-мых зрительных работ;
- достаточно равномерное распределение яркости на рабочих поверхнос-тях и в окружающем пространстве;
- отсутствие резких теней, прямой и отраженной блеклости;
- постоянство освещенности во времени;
- оптимальная направленность излучаемого осветительными приборами светового потока;
- долговечность, экономичность, электро- и пожаробезопасность, эстетич-ность, удобство и простота эксплуатации.
Для искусственного освещения помещений с вычислительной техникой следует использовать главным образом люминесцентные лампы, у которых высокая световая отдача (до 75 лм/Вт и более); продолжительный срок службы (до 10 000 ч), малая яркость светящейся поверхности, близкий к естественному спектр излучения, что обеспечивает хорошую цветопередачу. Наиболее приемлемыми являются люминесцентные лампы белого света и тепло-белого света мощностью 20, 40, 80 Вт.
Для исключения засветки экранов дисплеев прямым световым потоком, светильники общего освещения располагают сбоку от рабочего места, параллельно линии зрения оператора и стене с окнами. Такое расположение светильников позволяет производить их последовательное включение по мере необходимости и исключает раздражение глаз чередующимися полосами света и тени, возникающее при поперечном расположении светильников.
Для обеспечения оптимальных условий зрительных работ пользователей дисплейных устройств необходима определенная световая отделка помещения. Для внутренней отделки интерьера помещений, где расположены ПЭВМ, должны использоваться диффузно-отражающие материалы с коэффициентом отражения для потолка - 0,7 - 0,8; для стен - 0,5 - 0,6; для пола - 0,3 -0,5.
На рабочем месте программиста зрительные работы являются средней точности и относятся к IV разряду, так как наименьший размер объекта различения изменяется от 0,5 до 1,0 мм. Контраст объекта с фоном и характеристика фона средние, поэтому зрительные работы относятся к подразделу «в». Поэтому норма освещенности на поверхности стола в зоне размещения рабочего документа должна быть 300 - 500 лк. Освещение не должно создавать бликов на поверхности экрана, а его освещенность не должна быть более 300 лк.
Освещенность рабочего места пользователя на исследуемом предприятии является совмещенной, расположение рабочих мест исключает попадание прямых солнечных лучей на экран дисплея и в глаза. В качестве источника искусственного освещения используют лампы дневного света.
Правильно спроектированное производственное освещение благотворно влияет на производственную среду, оказывая положительное психологическое воздействие на работающего человека, повышает безопасность труда и снижает травматизм.
Недостаточность освещения приводит к напряжению зрения, ослабляет внимание, приводит к наступлению преждевременной утомленности. Чрезмерно яркое освещение вызывает ослепление, раздражение и резь в глазах. Неправильное направление света на рабочем месте может создавать резкие тени, блики, дезориентировать работающего. Все эти причины могут привести к несчастному случаю или профзаболеваниям, поэтому столь важен правильный расчет освещенности.
Расчет освещенности:
Рациональное освещение рабочего места является одним из важнейших факторов, влияющих на эффективность трудовой деятельности человека, предупреждающих травматизм и профессиональные заболевания. Правильно организованное освещение создает благоприятные условия труда, повышает работоспособность и производительность труда. Освещение на рабочем месте программиста должно быть таким, чтобы работник мог без напряжения зрения выполнять свою работу. Утомляемость органов зрения зависит от ряда причин:
- недостаточность освещенности;
- чрезмерная освещенность;
- неправильное направление света.
Недостаточность освещения приводит к напряжению зрения, ослабляет внимание, приводит к наступлению преждевременной утомленности. Чрезмерно яркое освещение вызывает ослепление, раздражение и резь в глазах. Неправильное направление света на рабочем месте может создавать резкие тени, блики, дезориентировать работающего. Все эти причины могут привести к несчастному случаю или профзаболеваниям, поэтому столь важен правильный расчет освещенности.
Расчет освещенности рабочего места сводится к выбору системы освещения, определению необходимого числа светильников, их типа и размещения. Процесс работы программиста в таких условиях, когда естественное освещение недостаточно или отсутствует. Исходя из этого, рассчитаем параметры искусственного освещения.
Искусственное освещение выполняется посредством электрических источников света двух видов: ламп накаливания и люминесцентных ламп. Будем использовать люминесцентные лампы, которые по сравнению с лампами накаливания имеют существенные преимущества:
- по спектральному составу света они близки к дневному, естественному освещению;
- обладают более высоким КПД (в 1.5-2 раза выше, чем КПД ламп нака-ливания);
- обладают повышенной светоотдачей (в 3-4 раза выше, чем у ламп нака-ливания);
- более длительный срок службы.
Расчет освещения производится для комнаты площадью 36 м² , ширина которой 4.9 м, высота - 4.2 м. Воспользуемся методом светового потока.
Для определения количества светильников определим световой поток, падающий на поверхность по формуле:
 ,
где    F - рассчитываемый световой поток, Лм;
Е - нормированная минимальная освещенность, Лк (определяется по таблице).
Работу программиста, в соответствии с этой таблицей, можно отнести к разряду точных работ, следовательно, минимальная освещенность будет Е = 300 Лк при газоразрядных лампах;
S - площадь освещаемого помещения ( в нашем случае S = 36 м² );
Z - отношение средней освещенности к минимальной (обычно принимается равным 1.1-1.2 , пусть Z = 1.1);
К - коэффициент запаса, учитывающий уменьшение светового потока лампы в результате загрязнения светильников в процессе эксплуатации (его значение определяется по таблице коэффициентов запаса для различных помещений и в нашем случае К = 1.5);
n - коэффициент использования, (выражается отношением светового потока, падающего на расчетную поверхность, к суммарному потоку всех ламп и исчисляется в долях единицы; зависит от характеристик светильника, размеров помещения, окраски стен и потолка, характеризуемых коэффициентами отражения от стен (Рс) и потолка (Рп)), значение коэффициентов Рс и Рп определим по таблице зависимостей коэффициентов отражения от характера поверхности: Рс=30%, Рп=50%. Значение n определим по таблице коэффициентов использования различных светильников. Для этого вычислим индекс помещения по формуле:
,
где    S - площадь помещения, S = 36 м²;
h - расчетная высота подвеса, h = 3.39 м;
A - ширина помещения, А = 4.9 м;
В - длина помещения, В = 7.35 м.
Подставив значения получим:

Зная индекс помещения I, Рс и Рп, по таблице находим n = 0.28.
Подставим все значения в формулу для определения светового потока F:
 Лм
Для освещения выбираем люминесцентные лампы типа ЛБ40-1, световой поток которых F = 4320 Лк.
Рассчитаем необходимое количество ламп по формуле:
 ,
где    N - определяемое число ламп;
F - световой поток, F = 63642,857 Лм;
F_л- световой поток лампы, F_л = 4320 Лм.
 шт.
При выборе осветительных приборов используем светильники типа ОД. Каждый светильник комплектуется двумя лампами. Размещаются светильники двумя рядами, по четыре в каждом ряду.

4.6. Пожарная безопасность

Особое внимание к пожарной безопасности является обоснованным, так как в случае пожара будет нанесен значительный материальный ущерб (даже если в помещении находится один компьютер), и возможна угроза жизни и здоровью людей.
Источниками пожара при работе программиста с компьютером могут быть ЭВМ, электропроводка, действующие системы отопления, вентиляции и кондиционирования воздуха, бытовые приборы.
В современных ЭВМ очень высокая плотность размещения элементов электронных схем. В непосредственной близости друг от друга располагаются соединительные провода, коммутационные кабели. При протекании по ним электрического тока выделяется значительное количество теплоты, что может привести к повышению температуры отдельных узлов до 80-100 °С. При этом возможно оплавление изоляции соединительных проводов, их оголение и, как следствие, короткое замыкание, которое сопровождается искрением, ведет к недопустимым перегрузкам элементов электронных схем. Последние, перегреваясь, сгорают с разбрызгиванием искр.
Для отвода избыточной теплоты от ЭВМ служат системы вентиляции и кондиционирования воздуха. Однако постоянно действующие системы представляют дополнительную пожарную опасность, так как, с одной стороны, они обеспечивают подачу кислорода-окислителя, с другой стороны - при возникновении пожара быстро распространяют огонь и продукты горения по всем устройствам.
Помещения, где установлена вычислительная техника, относятся к категории «Д» – помещения, где находятся твердые горючие и трудно горючие вещества и материалы в холодном состоянии. Возможной причиной возникновения пожара может быть неисправность электрооборудования. Для предупреждения этого необходимо проводить профилактические осмотры оборудования.
Пожарная профилактика - это комплекс организационных и технических мероприятий, направленных на обеспечение безопасности людей, на предотвращение пожара, ограничение его распространения, а также на создание условий для успешного тушения пожара.
При работе в помещениях категории «Д» необходимо:
– выполнять правила пожарной безопасности помещений для ЭВМ, хранилищ информации, установок кондиционирования и систем энергопитания;
– выполнять правила пожарной безопасности при ремонтно-профилактических работах;
– установить в помещении систему автоматической пожарной сигнализации пожаротушения;
– хранить горючие жидкости в металлической, плотно закрывающейся таре, и убирать по окончанию работы в сейф;
– съемные узлы ЭВМ необходимо ремонтировать в отдельном специальном помещении;
– использовать низковольтовые паяльники, устанавливаемые на несгораемой подставке.
Обязательным условием тушения пожара на ВЦ является отключение электричества. Для тушения пожаров на ВЦ наиболее эффективно применение огнетушителей типа ОУ–5, ОП–5–01. Преимуществом использования последнего является также и то, что в момент тушения устройство может находиться под напряжением. Огнетушители располагаются из расчета один на 40-50 м² площади, но не менее двух в помещении.
В помещении может быть установлена пожарная сигнализация – тепловые извещатели с плавкими предохранителями. Это необходимо при большой концентрации средств вычислительной техники.
В заключение следует заметить, что современные производители вычислительной техники в последнее время стараются максимально удовлетворить условиям безопасности и удобства программиста при работе с компьютером, что служит значительному снижению травматизма и профессиональных заболеваний. К таким нововведениям можно отнести мониторы с низким уровнем электромагнитного излучения, энергосберегающие функции оборудования (мониторов, процессоров, жестких дисков), а также все время повышающуюся эргономичность компьютерной техники.

ЗАКЛЮЧЕНИЕ

В результате проделанной работы была разработана и реализована подсистема обработки и фильтрации звукового сигнала в составе системы обработки аудиоинформации. Были разработаны и программно реализованы алгоритмы, позволяющие изменять исходный звуковой сигнал с целью изменения характеристик звучания. Были реализованы следующие методы обработки и фильтрации звукового сигнала: изменение основных параметров цифрового звука (частота дискретизации, битрейт, число каналов), редактирование темпа звука ,изменение общего уровня громкости, эффекты возрастающей и затухающей громкости, эха и реверберации, обращение звука. Также была реализована возможность изменения структуры звукового сигнала: удаление, копирование, вставка.
В результате проделанной работы была программная оболочка, позволяющая осуществить необходимые преобразования звуковых сигналов, записанных в файле.