--PAGE_BREAK--Разработанная подсистема является неотъемлемой часть системы обработки аудиоинформации, предназначенной для обработки и кодирования звуковых сигналов. Обработка позволяет преобразовать исходный звуковой сигнал для получения необходимых характеристик его звучания перед началом кодирования. Разработанная подсистема применяется к звуковым сигналам для их подготовки к кодированию в соответствующей подсистеме. Посредством применения системы обработки аудиоинформации можно преобразовать звуковые сигналы к требуемому виду и сжать для уменьшения занимаемого ими размера.
Созданную систему следует рассматривать как исследовательскую систему, предназначенную для выявления эмпирических закономерностей в предметной области и дальнейшую разработку в направлении большей автоматизации процесса преобразования звуковых сигналов.
СПИСОК ЛИТЕРАТУРЫ 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.Евгений Музыченко. Часто задаваемые вопросы по цифровому представлению звуковых сигналов. www.websound.ru/articles/theory/dgaudfaq.htm (22.05.2006).
16. Евгений Музыченко. Часто задаваемые вопросы электронному созданию и обработке звука www.websound.ru/articles/theory/dgaudfaq.htm (22.05.2006).
17. Дмитрий Малышев. Звук: немного теории. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
18. Дмитрий Шмунк. Восприятие и сжатие звука. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
19. Александр Радзишевский. Аналоговый блюз. www.websound.ru/articles/theory/sound_user.htm (22.05.2006).
20. Александр Радзишевский, Александр Чижов. Цифровой звук – обо всем по-порядку. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
21. Евгений Музыченко. Принципы цифрового звука. www.websound.ru/articles/theory/digsnd.htm (22.05.2006).
22. Дмитрий Михайлов. Параметры цифрового звука. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
23. Дмитрий Михайлов. Обработка звука – фильтры. www.websound.ru/articles/theory/filter.htm (22.05.2006).
24. Максим Лядов. FAQ по звуку — свежий взгляд на звуковые вопросы и ответы. www.ixbt.com/multimedia/sound-faq.shtml (22.05.2006).
25. Александр Радзишевский. Пространственное звучание (3D-звук). www.websound.ru/articles/technol/3dsound.htm (22.05.2006).
26. Александр Радзишевский. Способы преобразования звука, звуковые эффекты. www.websound.ru/articles/processing/effects.htm (22.05.2006).
27. Сергей Котов. Эффект реверберации — теория и практика. www.ixbt.com/multimedia/theory-of-reverb.shtml (22.05.2006).
28. Дмитрий Шмунк. Восприятие и сжатие звука. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
29. Дмитрий Шмунк. Восприятие и сжатие звука. www.websound.ru/articles/theory/sound-theory.htm (22.05.2006).
30.Дмитрий Шмунк. Восприятие и сжатие звука. 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 WaveOutGetNumDevs0 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 WaveInGetNumDevs0 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
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.CaptionS2 then TimePosition.Caption := S2;
продолжение
--PAGE_BREAK-- {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 := 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 i1 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
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;
продолжение
--PAGE_BREAK-- 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'smike@pochta.ru', 'О программе', 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
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
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:Andrei512@narod.ru'), 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
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
PaintBox1.Repaint;
end;
procedure TMainForm.ButtonZoomOutClick(Sender: TObject);
begin
SamplesPerPoint := SamplesPerPoint * 2;
PaintBox1.Repaint;
end;
procedure TMainForm.AudioOptionsButtonClick(Sender: TObject);
продолжение
--PAGE_BREAK--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
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
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
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
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
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
begin
AudioData.ReadSample(NumberOfSample, Channel, Sample1);
Sample := Sample1;
while (Sample = Sample1)and(NumberOfSample
begin
Inc(NumberOfSample);
if NumberOfSample
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
Data.Position := Number*nBlockAlign + Channel*(nBlockAlign div nChannels);
end;
if nBitsPerSample
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 (Smp1Smp2) or (Smp1>Smp)and(Smp
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;
продолжение
--PAGE_BREAK-- 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
AudioGeter.ReadSample(Start+i, Channel, Samp2)
else
Samp2 := 0;
Value := Samp1 + Samp2;
if (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 i0 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 iCount do
begin
AudioData.ReadSample(Start+i, Channel, Smp1);
if i+1Count 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
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 iCount do
begin
AudioData.ReadSample(Start+i, Channel, Smp1);
if i+1Count 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 AudioSize0 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.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
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
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
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
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
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
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
else Value := MaxValue;
AudioData.WriteSample(i, Channel, Value);
Volume := Volume + FinalVolume/Count;
end;
end;
end;
end.
ПРИЛОЖЕНИЕ 2 РУКОВОДСТВО ПРОГРАММИСТА
продолжение
--PAGE_BREAK-- продолжение
--PAGE_BREAK--– изменение темпа: замедление или ускорение скорости воспроизведения звукового сигнала;
– изменение общего уровня громкости: увеличение или уменьшение общего уровня громкости.;
– эффект возрастания громкости: плавное увеличение громкости от нулевого уровня в начале фрагмента до максимального в конце;
– эффект затухания громкости: плавное уменьшение громкости от максимального уровня в начале фрагмента до нулевого в конце.
Обработка сигнала – это сложная и, главное, ресурсоемкая процедура. Она сравнительно недавно стала проводиться в цифровых устройствах – раньше различные эффекты звучания и другие достигались путем обработки звука в аналоговых приборах. В аналоговой аппаратуре звук в виде электрических колебаний проходит через различные тракты (блоки электрических элементов), чем достигается изменение фазы, спектра и амплитуды сигнала. Однако такой способ обработки имеет массу недостатков. Возможность же использования цифровых устройств имеет неоспоримые преимущества. Качество обработки сигналов в них намного меньше зависит от качества аппаратуры. Кроме того, для различных манипуляций со звуком не требуется постоянная смена оборудования. И, самое главное, поскольку обработка ведется программным путем, для нее открываются просто невероятные возможности, которые ограничены лишь мощностью компьютеров (а она увеличивается с каждым днем) и фантазией человека.
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++ соответственно и обладают при этом возможностями быстрой разработки и проектирования визуальных интерфейсов.
продолжение
--PAGE_BREAK--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)
где ai, bi – это так называемые коэффициенты Фурье, рассчитывающиеся по некоторой формуле.
На рис. 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 = {A1,A2,…,An} – массив амплитуд звукового сигнала.
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации, битрейта и размера файла.
Ti – Ti-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*Кол;
T1i = Ti + 1*То;
T2i = Ti + 2*То;
…
ТКолi = Ti + Кол*То;
A1i = Гр/100*Ai;
A2i = Гр/100*A1i;
…
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
16. Если (i — Start)
17. Smp ::= 0;
продолжение
--PAGE_BREAK--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
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 = Ti – Ti-1.
2.3. Описание алгоритма создания эффекта эха 2.3.1. Назначение и характеристика алгоритма создания эффекта эха Данный алгоритм применяется к исходному звуковому сигналу для создания эффекта эха: реализация повторения звукового сигнала с помощью временных преобразований таким образом, чтобы человеческое ухо воспринимало полученный сигнал как эхо. При этом слух перестает субъективно воспринимать отражения, как призвуки основного сигнала, и начинает воспринимать их как повторения. Эхо обычно реализуется так же, как и естественное — с затуханием повторяющихся копий.
2.3.2. Используемая информация При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени;
n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-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*Кол + То;
T1i = Tn + Ti + То;
T2i = 2*Tn + Ti + 2*То;
…
ТКолi =Кол*Тn + Ti + Кол*То;
A1i = Гр/100*Ai;
A2i = Гр/100*A1i;
…
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)
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
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 = Ti – Ti-1.
2.4. Описание алгоритма изменения темпа звука 2.4.1. Назначение и характеристика алгоритма изменения темпа звука Данный алгоритм применяется для замедления или ускорения скорости воспроизведения звукового сигнала.
2.4.2. Используемая информация При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-1 определяется частотой дискретизации.
При реализации алгоритма учитываются следующие параметры, которые подаются в качестве параметров на вход алгоритма: величина новой скорости воспроизведения в процентах от текущей (Ск).
2.4.3. Результаты решения В результате реализации алгоритма формируется новый массив значений времени T’, массив с амлитудами A остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.
2.4.4. Математическое описание алгоритма изменения темпа звука Для получения выходного массива T’ используются следующие формулы:
T’1 = T1 * Ск/100;
T’2 = T2 * Ск/100;
…
T’n = Tn * Ск/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. Если iCount, то переход к п.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 = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-1 определяется частотой дискретизации.
При реализации алгоритма учитываются следующие параметры, которые подаются в качестве параметров на вход алгоритма: величина новой громкости звукового сигнала в процентах от текущей (Гр).
2.5.3. Результаты решения В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.
продолжение
--PAGE_BREAK--2.5.4. Математическое описание алгоритма изменения громкости звука Для получения выходного массива A’ используются следующие формулы:
A’1 = А1 * Гр/100;
A’2 = А2 * Гр/100;
…
A’n = An * Гр/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
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 = Ti – Ti-1.
2.6. Описание алгоритма создания эффекта возрастающей громкости 2.6.1. Назначение и характеристика алгоритма изменения громкости звука Данный алгоритм применяется для плавного увеличения громкости от нулевого уровня в начале фрагмента до максимального в конце.
2.6.2. Используемая информация При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-1 определяется частотой дискретизации.
2.6.3. Результаты решения В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.
2.6.4. Математическое описание алгоритма создания эффекта возрастающей громкости Для получения выходного массива A’ используются следующие формулы:
A’1 = А1 * 1/n;
A’2 = А2 * 2/n;
…
A’n = An.
Описание используемых обозначений приведено в п.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
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 = Ti – Ti-1.
2.7. Описание алгоритма создания эффекта затухающей громкости 2.7.1. Назначение и характеристика алгоритма создания эффекта затухающей громкости Данный алгоритм применяется для плавного уменьшения громкости от максимального уровня в начале фрагмента до нулевого в конце.
2.7.2. Используемая информация При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-1 определяется частотой дискретизации.
2.7.3. Результаты решения В результате реализации алгоритма формируется новый массив значений амплитуд A’, массив с временем T остается неизменным. Структура выходного файла при этом соответствует описанной в п.2.1.2.
2.7.4. Математическое описание алгоритма создания эффекта затухающей громкости Для получения выходного массива A’ используются следующие формулы:
n – количество временных интервалов;
A’1 = А1 * n/n;
A’2 = А2 * (n-1)/n;
…
A’n-1 = An-1 * 2/n;
A’n = An * 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
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 = Ti – Ti-1.
2.8. Описание алгоритма обращения звукового сигнала 2.8.1. Назначение и характеристика алгоритма создания эффекта затухающей громкости Данный алгоритм применяется для обращения воспроизведения звукового сигнала.
2.8.2. Используемая информация При реализации данного алгоритма используются массивы информации, сформированные из входных данных. Массивы содержат информацию о величине амплитуды звукового сигнала в определенные моменты времени. Количество пар массивов определяется числом каналов (ЧК).
A = {A1,A2,…,An} – массив амплитуд звукового сигнала;
T = {T1,T2,…,Tn} – массив со значениями времени, где n зависит от частоты дискретизации (ЧД), битрейта (Б) и размера файла;
Ti – Ti-1 определяется частотой дискретизации.
2.8.3. Результаты решения В результате реализации алгоритма формируются новые массивы значений амплитуд A’ и времени T’. Структура выходного файла при этом соответствует описанной в п.2.1.2.
2.8.4. Математическое описание алгоритма обращения звукового сигнала Для получения выходных массивов A’ и Т’ используются следующие формулы:
A’1 = Аn;
A’2 = Аn-1;
…
A’n-1 = A2;
A’n = A1;
T’1 = Аn;
продолжение
--PAGE_BREAK--T’2 = Аn-1;
…
T’n-1 = A2;
T’n = A1.
Описание используемых обозначений приведено в п.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 = Ti – Ti-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.
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.
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.
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. Используемые программы В подпрограмме используются следующие подпрограммы:
продолжение
--PAGE_BREAK--1) ReadSample(Number, Channel: LongInt; var Value: Integer) – процедура чтения данных из звукового файла;
2) WriteSample(Number, Channel: LongInt; Value: Integer) – процедура записи данных в звуковой файл.
2.12.5. Схема подпрограммы «SetVolumeOfAudio» Схема подпрограммы «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.
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.
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.
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
Параметры исходных звуковых сигналов, записанных в файле:
Первый звуковой сигнал:
Частота дискретизации: 44100 Hz;
Битрейт: 16;
Число каналов: 2.
Второй звуковой сигнал:
Частота дискретизации: 22050 Hz;
Битрейт: 16;
Число каналов: 2.
2.16.3. Контрольный пример Применение эффекта эха.
Установленные параметры эффекта: 2 отклика, 75% громкость, задержка между откликами 400 мс. Результат применения эффекта к исходному сигналу показан на рис.2.26.
Эффект эха
Рис.2.26
Применение эффекта реверберации.
Установленные параметры эффекта: 2 отражения, 70% громкость, задержка между отражениями 62 мс. Результат применения эффекта к исходному сигналу показан на рис.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. ОРГАНИЗАЦИОННО-ЭКОНОМИЧЕСКАЯ ЧАСТЬ
Обоснование необходимости разработки подсистемы обработки и фильтрации сигнала Подсистема обработки и фильтрации сигнала является неотъемлимой частью системы обработки аудиоинформации, предназначенной для редактирования и кодирования звуковых сигналов, записанных в файлах. Разрабатываемая система носит исследовательский характер и предназначена для поиска и отладки наиболее эффективных алгоритмов обработки звуковой информации. Реализация подсистемы позволит в значительной степени облегчить труд программиста-исследователя посредством автоматизации процесса обработки звуковых сигналов.
Подсистема обработки и фильтрации звуковых сигналов позволит редактировать основные параметры цифрового звука, модифицировать их структуру, применить различные эффекты для достижения необходимых характеристик звучания.
Уменьшение размера файлов, содержащих звуковую информацию, имеет большое значение как при их хранении, так и при пересылке по каналам связи. Таким образом, разработка системы позволит, помимо выполнения операций редактирования и преобразования звуковых сигналов, сэкономить на загрузке устройств хранения информации и снизить нагрузку на каналы связи.
продолжение
--PAGE_BREAK-- Расчет затрат на разработку подсистемы обработки и фильтрации сигнала Для определения величины расходов на создание подсистемы, используем прямой метод калькуляции.
Расчет сметы затрат осуществляется по следующим статьям
- расходы на основные и вспомогательные материалы;
- расходы на оплату труда исполнителей;
- расходы на социальные программы;
- расходы на содержание и амортизацию основных фондов;
- накладные расходы;
- прочие расходы.
К статье «Расходы на основные и вспомогательные материалы» относятся покупные изделия, необходимые для выполнения работы, перечисленные в табл. 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 мВт/м2.
Экспериментальное исследование характера и интенсивности излучения дисплея с целью определить воздействие электромагнитных излучений на пользователя при длительной работе показало, что уровни облучения в ультрафиолетовой, инфракрасной и видимой областях спектра оказались ниже допустимых значений. Таким образом, считается, что интенсивность излучения экрана дисплея не превышает предельно допустимой дозы радиации и, следовательно, условия труда можно отнести к безопасным.
Для дополнительного снижения излучений рекомендуется применять мониторы с пониженным уровнем излучения (MPR-II, TCO-92, TCO-99), устанавливать защитные экраны, которые поглощают до 100% ультрафиолетового излучения, ослабляют электростатическое поле на 99%, а также соблюдать регламентированные режимы труда и отдыха.
4.2. Электробезопасность при работе с компьютером Электрические установки, к которым относится практически все оборудование ЭВМ, представляют для человека большую потенциальную опасность, так как в процессе эксплуатации или проведении профилактических работ человек может коснуться частей, находящихся под напряжением.
Любое воздействие тока может привести к электрической травме, то есть к повреждению организма, вызванному действием электрического тока или электрической дуги.
При рассмотрении вопроса обеспечения электробезопасности разработчика необходимо выделить три основных фактора:
— электроустановки рабочего места программиста;
— вспомогательное электрооборудование;
— окружающая среда помещения.
К электроустройствам рабочего места относятся: компьютер, видеомонитор, принтер. К вспомогательному оборудованию относятся лампы местного освещения, вентиляторы и другие электрические приборы. Электрооборудование, перечисленное выше, относится к установкам напряжением до 1000 В, исключение составляют лишь дисплей, электронно-лучевые трубки, которых имеют напряжение в несколько киловольт.
Окружающая среда помещений, в которых работает программист, воздействует на электрическую изоляцию приборов и устройств, электрическое сопротивление тела человека и может создавать условия для поражения электрическим током.
Помещения, оборудованные вычислительной техникой, как правило, относятся к категории помещений без повышенной опасности, так как:
— относительная влажность воздуха не превышает 75%;
— нет токопроводящей пыли;
— температура не превышает длительное время 30 °С;
— отсутствует возможность одновременного прикосновения человека с имеющим соединение с землей металлическими конструкциями;
— отсутствие возможности прикоснуться к токоведущим частям оборудования;
— нет токопроводящих полов.
Таким образом, для предотвращения электротравматизма пользователя необходимо соблюдать требования безопасности, как при работе с обычной бытовой техникой.
4.3. Организация рабочего места инженера-программиста На инженера-программиста оказывают воздействие различные вредные и опасные факторы, которые отрицательно влияют на здоровье: излучение экрана монитора ПК, плохое проветривание и недостаточная освещенность помещений могут привести к заболеваниям организма различной степени тяжести.
Длительное нахождение человека в зоне вышеперечисленных воздействий может привести к профессиональному заболеванию, поэтому в данном разделе решается задача обеспечения безопасных условий труда инженера-программиста.
Главными элементами рабочего места программиста являются стол и кресло. Основным рабочим положением является положение сидя. Рабочая поза сидя вызывает минимальное утомление программиста. Рациональная планировка рабочего места предусматривает четкий порядок и постоянство размещения предметов, средств труда и документации. То, что требуется для выполнения работ чаще, расположено в зоне легкой досягаемости рабочего пространства. Моторное поле – пространство рабочего места, в котором могут осуществляться двигательные действия человека. Максимальная зона досягаемости рук – это часть моторного поля рабочего места, ограниченного дугами, описываемыми максимально вытянутыми руками при движении их в плечевом суставе. Оптимальная зона – часть моторного поля рабочего места, ограниченного дугами, описываемыми предплечьями при движении в локтевых суставах с опорой в точке локтя и с относительно неподвижным плечом. Схематично зоны досягаемости представлены на рис. 3.1.
Зоны досягаемости рук в горизонтальной плоскости
а – зона максимальной досягаемости;
б – зона досягаемости пальцев при вытянутой руке;
в – зона легкой досягаемости ладони;
г – оптимальное пространство для грубой ручной работы;
д – оптимальное пространство для тонкой ручной работы.
Рис.4.1
Оптимальное размещение предметов труда и документации в зонах досягаемости:
– дисплей размещается в зоне а (в центре);
– системный блок размещается в предусмотренной нише стола;
– клавиатура – в зоне г/д;
– “мышь” – в зоне в справа;
– сканер – в зоне а/б (слева);
– принтер – в зоне а (справа);
– документация: необходимая при работе – в зоне легкой досягаемости ладони – в; неиспользуемая постоянно – в выдвижных ящиках стола.
Схематично размещение основных и периферийных составляющих ПК представлено на рис. 4.2.
Размещение основных и периферийных составляющих ПК
продолжение
--PAGE_BREAK--Рис. 4.2
При компоновке рабочего места необходимо учитывать зоны досягаемости рук человека при расположении дисплеев, клавиатуры, системного блока и так далее. Высота рабочей поверхности стола должна регулироваться в пределах 680 – 800 мм, при отсутствии такой возможности высота рабочей поверхности стола должна составлять 725 мм.
Рабочий стол должен иметь пространство для постановки ног высотой не менее 600 мм, шириной не менее 500 мм, глубиной на уровне колен – не менее 450 мм и на уровне вытянутых ног – не менее 650 мм.
Экран видеомонитора должен находиться от глаз пользователя на оптимальном расстоянии 600 – 700 мм, но не ближе 500 мм с учетом размеров алфавитно-цифровых знаков и символов.
4.4. Требования к параметрам микроклимата помещения Под метеорологическими условиями понимают сочетание температуры, относительной влажности, скорости движения и запыленности воздуха. Перечисленные параметры оказывают огромное влияние на функциональную деятельность человека, его самочувствие и здоровье и на надежность средств вычислительной техники. Эти микроклиматические параметры влияют как каждый в отдельности, так и в различных сочетаниях.
Температура воздуха является одним из основных параметров, характеризующих тепловое состояние микроклимата. Суммарное тепловыделение в помещении поступает от:
— ЭВМ;
— вспомогательного оборудования;
— приборов освещения;
— людей;
— внешних источников.
Наибольшее количество теплоты выделяют ЭВМ и вспомогательное оборудование. Средняя величина тепловыделения от компьютеров колеблется до 100 Вт/м2. Тепловыделения от приборов освещения также велики. Удельная величина их составляет 35 Вт/м2.При этом, чем больше уровень освещенности, тем выше удельные величины тепловыделений. Количество теплоты от обслуживающего персонала незначительно. Оно зависит от числа работающих в помещении, интенсивности работы, выполняемой человеком.
К внешним источникам поступления теплоты относят теплоту, поступающую через окна от солнечной радиации, приток теплоты через непрозрачные ограждения конструкций. Интенсивность этих источников зависит от расположения здания, ориентации по частям света, цветовой гаммы и прочее.
С целью создания нормальных условий труда программиста, ГОСТом 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 м2, ширина которой 4.9 м, высота — 4.2 м. Воспользуемся методом светового потока.
Для определения количества светильников определим световой поток, падающий на поверхность по формуле:
,
где F — рассчитываемый световой поток, Лм;
Е — нормированная минимальная освещенность, Лк (определяется по таблице).
Работу программиста, в соответствии с этой таблицей, можно отнести к разряду точных работ, следовательно, минимальная освещенность будет Е = 300 Лк при газоразрядных лампах;
S — площадь освещаемого помещения ( в нашем случае S = 36 м2 );
Z — отношение средней освещенности к минимальной (обычно принимается равным 1.1-1.2, пусть Z = 1.1);
К — коэффициент запаса, учитывающий уменьшение светового потока лампы в результате загрязнения светильников в процессе эксплуатации (его значение определяется по таблице коэффициентов запаса для различных помещений и в нашем случае К = 1.5);
n — коэффициент использования, (выражается отношением светового потока, падающего на расчетную поверхность, к суммарному потоку всех ламп и исчисляется в долях единицы; зависит от характеристик светильника, размеров помещения, окраски стен и потолка, характеризуемых коэффициентами отражения от стен (Рс) и потолка (Рп)), значение коэффициентов Рс и Рп определим по таблице зависимостей коэффициентов отражения от характера поверхности: Рс=30%, Рп=50%. Значение n определим по таблице коэффициентов использования различных светильников. Для этого вычислим индекс помещения по формуле:
,
где S — площадь помещения, S = 36 м2;
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 м2 площади, но не менее двух в помещении.
В помещении может быть установлена пожарная сигнализация – тепловые извещатели с плавкими предохранителями. Это необходимо при большой концентрации средств вычислительной техники.
В заключение следует заметить, что современные производители вычислительной техники в последнее время стараются максимально удовлетворить условиям безопасности и удобства программиста при работе с компьютером, что служит значительному снижению травматизма и профессиональных заболеваний. К таким нововведениям можно отнести мониторы с низким уровнем электромагнитного излучения, энергосберегающие функции оборудования (мониторов, процессоров, жестких дисков), а также все время повышающуюся эргономичность компьютерной техники.
ЗАКЛЮЧЕНИЕ В результате проделанной работы была разработана и реализована подсистема обработки и фильтрации звукового сигнала в составе системы обработки аудиоинформации. Были разработаны и программно реализованы алгоритмы, позволяющие изменять исходный звуковой сигнал с целью изменения характеристик звучания. Были реализованы следующие методы обработки и фильтрации звукового сигнала: изменение основных параметров цифрового звука (частота дискретизации, битрейт, число каналов), редактирование темпа звука, изменение общего уровня громкости, эффекты возрастающей и затухающей громкости, эха и реверберации, обращение звука. Также была реализована возможность изменения структуры звукового сигнала: удаление, копирование, вставка.
В результате проделанной работы была программная оболочка, позволяющая осуществить необходимые преобразования звуковых сигналов, записанных в файле.