Aktuelle Zeit: 22.04.2019 18:34

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]




Ein neues Thema erstellen Auf das Thema antworten  [ 19 Beiträge ]  Gehe zu Seite Vorherige  1, 2
Autor Nachricht
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 18.01.2019 14:28 
Offline
Benutzeravatar

Registriert: 25.09.2016 01:42
Ich mal die Links zusammengetragen falls es jemand versuchen möchte. :)
Kenne mich mit bass leider nicht aus.

Bass.pbi:
http://www.un4seen.com/stuff/bass24-pb.zip

Bass DLL:
http://www.un4seen.com/download.php?bass24


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 18.01.2019 14:48 
Offline
Ein Admin
Benutzeravatar

Registriert: 29.08.2004 20:20
Wohnort: Saarbrücken
So ein Forum besteht halt auch nur aus Freiwilligen. Da hat nicht jeder dauernd Zeit einen kompletten Code zusammenzubasteln und ihn hier zu posten.

_________________
Freakscorner.de - Der Bastelkeller | Neustes Video: Neje DK - 1 Watt Laser Engraver
Ubuntu Gnome 18.04.1 LTS x64, PureBasic 5.60 x64 (außerdem 4.41, 4.50, 4.61, 5.00, 5.10, 5.11, 5.21, 5.22, 5.30, 5.31, 5.40, 5.50)
"Die deutsche Rechtschreibung ist Freeware, du darfst sie kostenlos nutzen – Aber sie ist nicht Open Source, d. h. du darfst sie nicht verändern oder in veränderter Form veröffentlichen."


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 18.01.2019 16:11 
Offline

Registriert: 27.11.2016 18:13
Wohnort: Erzgebirge
Hallo an Alle,

ich habe Then ja schon ein sehr tolles Beispiel und eine kleine Erklärung per PN gepostet.

Hier einmal ein ganz kleines Beispiel:

(Die benöigten Dateien (bass.dll, Beispiele und Doku) hat Then schon erhalten.)

Ich denke einfacher geht es kaum noch, oder? Man könnte sich neben der Bass.dll auch mit FFT beschäftigen. Aber muss das sein ?

Code:
Structure Sample
  l.w
  r.w
EndStructure

Procedure UpdateWaveImage(PBImage, *SampleData.Sample, SampleCount)
  Protected.i Width, Height, x, VOffsetL, VOffsetR, MUL
  Protected.i SamplesPerPixel, sample
  Protected.w MinL, MaxL, MinR, MaxR
  If *SampleData And SampleCount
    StartDrawing(ImageOutput(PBImage))
    DrawingMode(#PB_2DDrawing_Transparent)
    Width = OutputWidth() : Height = OutputHeight()
    VOffsetL = Height >> 2 : VOffsetR = VOffsetL + Height >> 1
    MUL = (VOffsetL * $19999) >> 16
    Box(0, 0, Width, Height, $FFFFFF)
    Line(0, VOffsetL, Width, 1, RGB(255,0,0))
    Line(0, VOffsetR, Width, 1, RGB(255,0,0))
    SamplesPerPixel = (SampleCount + Width - 1) / Width
    If SampleCount
      MinL = *SampleData\l : MinR = *SampleData\r : MaxL = MinL : MaxR = MinR     
      While SampleCount
        If *SampleData\l < MinL : MinL = *SampleData\l : ElseIf *SampleData\l > MaxL : MaxL = *SampleData\l : EndIf
        If *SampleData\r < MinR : MinR = *SampleData\r : ElseIf *SampleData\r > MaxR : MaxR = *SampleData\r : EndIf
        sample + 1 : SampleCount - 1
        If sample = SamplesPerPixel Or SampleCount = 0
          MinL = (MinL * MUL) >> 16 : MaxL = (MaxL * MUL) >> 16
          MinR = (MinR * MUL) >> 16 : MaxR = (MaxR * MUL) >> 16
          LineXY(x, VOffsetL - MinL, x, VOffsetL - MaxL, $01D1F5)
          LineXY(x, VOffsetR - MinR, x, VOffsetR - MaxR, $AA964C)
          MinL = *SampleData\l : MinR = *SampleData\r : MaxL = MinL : MaxR = MinR
          x + 1 : sample = 0
        EndIf
        *SampleData + 4
      Wend
    EndIf
    DrawText((Width/2)-(TextWidth("Linker Kanal")/2), VOffsetL-(TextHeight("Linker Kanal")/2), "Linker Kanal", RGB(0,0,0))
    DrawText((Width/2)-(TextWidth("Rechter Kanal")/2), VOffsetR-(TextHeight("Rechter Kanal")/2), "Rechter Kanal", RGB(0,0,0))
    StopDrawing()
  EndIf
EndProcedure

Global Filename.s, WaveImage, Channel, length, event

BASS_Init(-1, 44100, 0, 0, #Null)

Filename =  OpenFileRequester("","","Musik|*.mp3;*.wav",0)

Channel  = BASS_StreamCreateFile(#False, @Filename, 0, 0, #BASS_STREAM_PRESCAN|#BASS_STREAM_DECODE|#BASS_UNICODE)
BASS_ChannelSetPosition(Channel, BASS_ChannelSeconds2Bytes(Channel, 0), #BASS_POS_BYTE)
BASS_ChannelBytes2Seconds(Channel, BASS_ChannelGetLength(Channel, #BASS_POS_BYTE))
length = BASS_ChannelSeconds2Bytes(Channel, BASS_ChannelBytes2Seconds(Channel, BASS_ChannelGetLength(Channel, #BASS_POS_BYTE)))
Dim Buffer.Sample(length >> 2) ;Länge durch 4 reicht als Arraygröße
BASS_ChannelGetData(Channel, @Buffer(), length)

WaveImage = CreateImage(#PB_Any, 1900, 150)
UpdateWaveImage(WaveImage, @Buffer(), length >> 2)

UsePNGImageDecoder()
UsePNGImageEncoder()

If SaveImage(WaveImage, GetCurrentDirectory()+"Mp3-Bild.png", #PB_ImagePlugin_PNG)
  Debug "Gespeichert !!!"
Else
  Debug "Fehler !!!"
EndIf

Edit by NicTheQuick: Code-Tags gesetzt


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 18.01.2019 16:45 
Offline
Benutzeravatar

Registriert: 25.09.2016 01:42
Hab mal die bass.pbi überarbeitet und den manuellen Import Unsinn rausgenommen :)

Code:
Code:
;   BASS 2.4 C/C++ header file
;   Copyright (c) 1999-2014 Un4seen Developments Ltd.
;
;   See the BASS.CHM file for more detailed documentation
;
;   BASS v2.4.11.x Windows include for PureBasic v5.31
;   C to PB adaption by Roger Hågensen, 2015-03-23, http://forums.purebasic.com/
;   Modified by Mijikai 2019-01-18 https://www.purebasic.fr/english/
;
;   Changes from last update to the PB include files:
;   Things have been moved around some to make maintenance a little easier.
;   Some of the macros and assert stuff was a little broken, these have been fixed and moved into bass_test.pb
;   BASS_ChannelSetAttributeEx() and BASS_ChannelGetAttributeEx(), BASS_ChannelGetLevelEx() added.
;   BASS_MusicLoad() and BASS_SampleLoad() had the wrong number of parameters, missing freq.l and max.l respectively.
;   Several constants have been added.
;   Special wrappers, file/memory loading macros and prototypes have been removed, definitions/parameters should now match what is in the BASS manual.
;   All Unicode prototypes and compiler exceptions removed, this brings the include closer to the original BASS.h file.
;
;   General changes when porting from bass.h to bass.pbi:
;   As much of the non-Windows platform stuff is kept as possible (iOS, Windows CE, Linux, MacOS) even if PureBasic do not support all those platforms.
;   Windows spesific stuff has compiletime check and inclusion to make the include itself as neutral as possible and match BASS.h where possible.
;  MacOS and Linux alternatives are left where encountered, some fiddling around may be needed though.
;   Any callback definitions are retained but commented out so you can see how they should be made.
;   Some C stuff has been dropped when not needed or an alternative implementation added instead.

;C to PB porting hints:
;PureBasic has no direct match for C like typedefs, just treat these as longs instead.
;TRUE is 1 (#TRUE)
;FALSE is 0 (#FALSE)
;BYTE is a byte
;WORD is a word
;DWORD is a long
;QWORD is a quad
;BOOL is a long
;HMUSIC is a long,   MOD music handle
;HSAMPLE is a long,   sample handle
;HCHANNEL is a long,   playing sample's channel handle
;HSTREAM is a long,   sample stream handle
;HRECORD is a long,   recording handle
;HSYNC is a long,      synchronizer handle
;HDSP is a long,      DSP handle
;HFX is a long,      DX8 effect handle
;HPLUGIN is a long,   Plugin handle

;- BASS version constants
#BASSVERSION      = $02040A00 ;BASS API version this include was made for.
#BASSVERSIONTEXT   = "2.4"

;- BASS Error codes returned by BASS_GetErrorCode
#BASS_OK               = 0   ;all is OK
#BASS_ERROR_MEM      = 1   ;memory error
#BASS_ERROR_FILEOPEN   = 2   ;can't open the file
#BASS_ERROR_DRIVER   = 3   ;can't find a free/valid driver
#BASS_ERROR_BUFLOST   = 4   ;the sample buffer was lost
#BASS_ERROR_HANDLE   = 5   ;invalid handle
#BASS_ERROR_FORMAT   = 6   ;unsupported sample format
#BASS_ERROR_POSITION   = 7   ;invalid playback position
#BASS_ERROR_INIT      = 8   ;BASS_Init has not been successfully called
#BASS_ERROR_START      = 9   ;BASS_Start has not been successfully called
#BASS_ERROR_ALREADY   = 14   ;already initialized
#BASS_ERROR_NOCHAN   = 18   ;can't get a free channel
#BASS_ERROR_ILLTYPE   = 19   ;an illegal type was specified
#BASS_ERROR_ILLPARAM   = 20   ;an illegal parameter was specified
#BASS_ERROR_NO3D      = 21   ;no 3D support
#BASS_ERROR_NOEAX      = 22   ;no EAX support
#BASS_ERROR_DEVICE   = 23   ;illegal device number
#BASS_ERROR_NOPLAY   = 24   ;not playing
#BASS_ERROR_FREQ      = 25   ;illegal sample rate
#BASS_ERROR_NOTFILE   = 27   ;the stream is not a file stream
#BASS_ERROR_NOHW      = 29   ;no hardware voices available
#BASS_ERROR_EMPTY      = 31   ;the MOD music has no sequence Data
#BASS_ERROR_NONET      = 32   ;no internet connection could be opened
#BASS_ERROR_CREATE   = 33   ;couldn't create the file
#BASS_ERROR_NOFX      = 34   ;effects are not available
#BASS_ERROR_NOTAVAIL   = 37   ;requested Data is not available
#BASS_ERROR_DECODE   = 38   ;the channel is/isn't a "decoding channel"
#BASS_ERROR_DX         = 39   ;a sufficient DirectX version is not installed
#BASS_ERROR_TIMEOUT   = 40   ;connection timedout
#BASS_ERROR_FILEFORM   = 41   ;unsupported file format
#BASS_ERROR_SPEAKER   = 42   ;unavailable speaker
#BASS_ERROR_VERSION   = 43   ;invalid BASS version (used by add-ons)
#BASS_ERROR_CODEC      = 44   ;codec is Not available/supported
#BASS_ERROR_ENDED      = 45   ;the channel/file has ended
#BASS_ERROR_BUSY      = 46   ;the device is busy
#BASS_ERROR_UNKNOWN   = -1   ;some other mystery error

;- BASS_SetConfig options
#BASS_CONFIG_BUFFER            = 0
#BASS_CONFIG_UPDATEPERIOD      = 1
#BASS_CONFIG_GVOL_SAMPLE      = 4
#BASS_CONFIG_GVOL_STREAM      = 5
#BASS_CONFIG_GVOL_MUSIC         = 6
#BASS_CONFIG_CURVE_VOL         = 7
#BASS_CONFIG_CURVE_PAN         = 8
#BASS_CONFIG_FLOATDSP         = 9
#BASS_CONFIG_3DALGORITHM      = 10
#BASS_CONFIG_NET_TIMEOUT      = 11
#BASS_CONFIG_NET_BUFFER         = 12
#BASS_CONFIG_PAUSE_NOPLAY      = 13
#BASS_CONFIG_NET_PREBUF         = 15
#BASS_CONFIG_NET_PASSIVE      = 18
#BASS_CONFIG_REC_BUFFER         = 19
#BASS_CONFIG_NET_PLAYLIST      = 21
#BASS_CONFIG_MUSIC_VIRTUAL      = 22
#BASS_CONFIG_VERIFY            = 23
#BASS_CONFIG_UPDATETHREADS      = 24
#BASS_CONFIG_DEV_BUFFER         = 27
#BASS_CONFIG_VISTA_TRUEPOS      = 30
#BASS_CONFIG_IOS_MIXAUDIO      = 34
#BASS_CONFIG_DEV_DEFAULT      = 36
#BASS_CONFIG_NET_READTIMEOUT   = 37
#BASS_CONFIG_VISTA_SPEAKERS   = 38
#BASS_CONFIG_IOS_SPEAKER      = 39
#BASS_CONFIG_MF_DISABLE         = 40
#BASS_CONFIG_HANDLES            = 41
#BASS_CONFIG_UNICODE            = 42
#BASS_CONFIG_SRC               = 43
#BASS_CONFIG_SRC_SAMPLE         = 44
#BASS_CONFIG_ASYNCFILE_BUFFER   = 45
#BASS_CONFIG_OGG_PRESCAN      = 47
#BASS_CONFIG_MF_VIDEO         = 48
#BASS_CONFIG_AIRPLAY            = 49
#BASS_CONFIG_DEV_NONSTOP      = 50
#BASS_CONFIG_IOS_NOCATEGORY   = 51
#BASS_CONFIG_VERIFY_NET         = 52

;- BASS_SetConfigPtr options
#BASS_CONFIG_NET_AGENT   = 16
#BASS_CONFIG_NET_PROXY   = 17
#BASS_CONFIG_IOS_NOTIFY   = 46

;- BASS_Init flags
#BASS_DEVICE_8BITS      = $1      ;use 8 bit resolution, else 16 bit
#BASS_DEVICE_MONO         = $2      ;use mono, else stereo
#BASS_DEVICE_3D         = $4      ;enable 3D functionality
#BASS_DEVICE_LATENCY      = $100   ;calculate device latency (BASS_INFO struct)
#BASS_DEVICE_CPSPEAKERS   = $400   ;detect speakers via Windows control panel
#BASS_DEVICE_SPEAKERS   = $800   ;force enabling of speaker assignment
#BASS_DEVICE_NOSPEAKER   = $1000   ;ignore speaker arrangement
#BASS_DEVICE_DMIX         = $2000   ;use ALSA "dmix" plugin
#BASS_DEVICE_FREQ         = $4000   ;set device sample rate

;- DirectSound interfaces (For use With BASS_GetDSoundObject)
#BASS_OBJECT_DS      = 1   ;IDirectSound
#BASS_OBJECT_DS3DL   = 2   ;IDirectSound3DListener

;- Device info structure
Structure BASS_DEVICEINFO
   *name   ;description
   *driver ;driver
   flags.l
EndStructure

;- BASS_DEVICEINFO flags
#BASS_DEVICE_ENABLED   = $1
#BASS_DEVICE_DEFAULT   = $2
#BASS_DEVICE_INIT      = $4

#BASS_DEVICE_TYPE_MASK         = $ff000000
#BASS_DEVICE_TYPE_NETWORK      = $01000000
#BASS_DEVICE_TYPE_SPEAKERS      = $02000000
#BASS_DEVICE_TYPE_LINE         = $03000000
#BASS_DEVICE_TYPE_HEADPHONES   = $04000000
#BASS_DEVICE_TYPE_MICROPHONE   = $05000000
#BASS_DEVICE_TYPE_HEADSET      = $06000000
#BASS_DEVICE_TYPE_HANDSET      = $07000000
#BASS_DEVICE_TYPE_DIGITAL      = $08000000
#BASS_DEVICE_TYPE_SPDIF         = $09000000
#BASS_DEVICE_TYPE_HDMI         = $0a000000
#BASS_DEVICE_TYPE_DISPLAYPORT   = $40000000

;- BASS_GetDeviceInfo flags
#BASS_DEVICES_AIRPLAY   = $1000000

Structure BASS_INFO
   flags.l     ;device capabilities (DSCAPS_xxx flags)
   hwsize.l      ;size of total device hardware memory
   hwfree.l      ;size of free device hardware memory
   freesam.l   ;number of free sample slots in the hardware
   free3d.l      ;number of free 3D sample slots in the hardware
   minrate.l   ;min sample rate supported by the hardware
   maxrate.l   ;max sample rate supported by the hardware
   eax.l         ;device supports EAX? (always FALSE if BASS_DEVICE_3D was not used)
   minbuf.l      ;recommended minimum buffer length in ms (requires BASS_DEVICE_LATENCY)
   dsver.l      ;DirectSound version
   latency.l   ;delay (in ms) before start of playback (requires BASS_DEVICE_LATENCY)
   initflags.l   ;BASS_Init "flags" parameter
   speakers.l   ;number of speakers available
   freq.l      ;current output rate
EndStructure

;- BASS_INFO flags (from DSOUND.H)
#DSCAPS_CONTINUOUSRATE  = $00000010   ;supports all sample rates between min/maxrate
#DSCAPS_EMULDRIVER      = $00000020   ;device does NOT have hardware DirectSound support
#DSCAPS_CERTIFIED       = $00000040   ;device driver has been certified by Microsoft
#DSCAPS_SECONDARYMONO   = $00000100   ;mono
#DSCAPS_SECONDARYSTEREO = $00000200   ;stereo
#DSCAPS_SECONDARY8BIT   = $00000400   ;8 bit
#DSCAPS_SECONDARY16BIT  = $00000800   ;16 bit

;- Recording device info Structure
Structure BASS_RECORDINFO
   flags.l    ;device capabilities (DSCCAPS_xxx flags)
   formats.l  ;supported standard formats (WAVE_FORMAT_xxx flags)
   inputs.l     ;number of inputs
   singlein.l ;TRUE = only 1 input can be set at a time
   freq.l     ;current input rate
EndStructure

;- BASS_RECORDINFO flags (from DSOUND.H)
#DSCCAPS_EMULDRIVER = #DSCAPS_EMULDRIVER   ;device does NOT have hardware DirectSound recording support
#DSCCAPS_CERTIFIED  = #DSCAPS_CERTIFIED   ;device driver has been certified by Microsoft

;- defines for formats field of BASS_RECORDINFO (from MMSYSTEM.H)
#WAVE_FORMAT_1M08 = $00000001 ;11.025 kHz, Mono,   8-bit
#WAVE_FORMAT_1S08 = $00000002   ;11.025 kHz, Stereo, 8-bit
#WAVE_FORMAT_1M16 = $00000004   ;11.025 kHz, Mono,   16-bit
#WAVE_FORMAT_1S16 = $00000008   ;11.025 kHz, Stereo, 16-bit
#WAVE_FORMAT_2M08 = $00000010   ;22.05  kHz, Mono,   8-bit
#WAVE_FORMAT_2S08 = $00000020   ;22.05  kHz, Stereo, 8-bit
#WAVE_FORMAT_2M16 = $00000040   ;22.05  kHz, Mono,   16-bit
#WAVE_FORMAT_2S16 = $00000080   ;22.05  kHz, Stereo, 16-bit
#WAVE_FORMAT_4M08 = $00000100   ;44.1   kHz, Mono,   8-bit
#WAVE_FORMAT_4S08 = $00000200   ;44.1   kHz, Stereo, 8-bit
#WAVE_FORMAT_4M16 = $00000400   ;44.1   kHz, Mono,   16-bit
#WAVE_FORMAT_4S16 = $00000800   ;44.1   kHz, Stereo, 16-bit

;- Sample info structure
Structure BASS_SAMPLE
   freq.l     ;default playback rate
   volume.f     ;default volume (0-1)
   pan.f        ;default pan (-1=left, 0=middle, 1=right)
   flags.l     ;BASS_SAMPLE_xxx flags
   length.l     ;length (in bytes)
   max.l        ;maximum simultaneous playbacks
   origres.l  ;original resolution bits
   chans.l     ;number of channels
   mingap.l     ;minimum gap (ms) between creating channels
   mode3d.l     ;BASS_3DMODE_xxx mode
   mindist.f  ;minimum distance
   maxdist.f  ;maximum distance
   iangle.l     ;angle of inside projection cone
   oangle.l     ;angle of outside projection cone
   outvol.f     ;delta-volume outside the projection cone
   vam.l        ;voice allocation/management flags (BASS_VAM_xxx)
   priority.l ;priority (0=lowest, 0xffffffff=highest)
EndStructure

;- SAMPLE flags
#BASS_SAMPLE_8BITS     = 1      ;8 bit
#BASS_SAMPLE_FLOAT     = 256     ;32-bit floating-point
#BASS_SAMPLE_MONO      = 2        ;mono
#BASS_SAMPLE_LOOP      = 4        ;looped
#BASS_SAMPLE_3D        = 8        ;3D functionality
#BASS_SAMPLE_SOFTWARE  = 16     ;not using hardware mixing
#BASS_SAMPLE_MUTEMAX   = 32     ;mute at max distance (3D only)
#BASS_SAMPLE_VAM       = 64     ;DX7 voice allocation & management
#BASS_SAMPLE_FX        = 128     ;old implementation of DX8 effects
#BASS_SAMPLE_OVER_VOL  = $10000 ;override lowest volume
#BASS_SAMPLE_OVER_POS  = $20000 ;override longest playing
#BASS_SAMPLE_OVER_DIST = $30000 ;override furthest from listener (3D only)

;- STREAM flags
#BASS_STREAM_PRESCAN  = $20000  ;enable pin-point seeking/length (MP3/MP2/MP1)
#BASS_MP3_SETPOS      = #BASS_STREAM_PRESCAN
#BASS_STREAM_AUTOFREE = $40000  ;automatically free the stream when it stop/ends
#BASS_STREAM_RESTRATE = $80000  ;restrict the download rate of internet file streams
#BASS_STREAM_BLOCK    = $100000 ;download/play internet file stream in small blocks
#BASS_STREAM_DECODE   = $200000 ;don't play the stream, only decode (BASS_ChannelGetData)
#BASS_STREAM_STATUS   = $800000 ;give server status info (HTTP/ICY tags) in DOWNLOADPROC

;- MUSIC flags
#BASS_MUSIC_FLOAT      = #BASS_SAMPLE_FLOAT
#BASS_MUSIC_MONO       = #BASS_SAMPLE_MONO
#BASS_MUSIC_LOOP       = #BASS_SAMPLE_LOOP
#BASS_MUSIC_3D         = #BASS_SAMPLE_3D
#BASS_MUSIC_FX         = #BASS_SAMPLE_FX
#BASS_MUSIC_AUTOFREE   = #BASS_STREAM_AUTOFREE
#BASS_MUSIC_DECODE     = #BASS_STREAM_DECODE
#BASS_MUSIC_PRESCAN    = #BASS_STREAM_PRESCAN ;calculate playback length
#BASS_MUSIC_CALCLEN    = #BASS_MUSIC_PRESCAN
#BASS_MUSIC_RAMP       = $200      ;normal ramping
#BASS_MUSIC_RAMPS      = $400      ;sensitive ramping
#BASS_MUSIC_SURROUND   = $800      ;surround sound
#BASS_MUSIC_SURROUND2  = $1000   ;surround sound (mode 2)
#BASS_MUSIC_FT2MOD     = $2000   ;play .MOD as FastTracker 2 does
#BASS_MUSIC_PT1MOD     = $4000   ;play .MOD as ProTracker 1 does
#BASS_MUSIC_NONINTER   = $10000   ;non-interpolated sample mixing
#BASS_MUSIC_SINCINTER  = $800000   ;sinc interpolated sample mixing
#BASS_MUSIC_POSRESET   = $8000   ;stop all notes when moving position
#BASS_MUSIC_POSRESETEX = $400000   ;stop all notes and reset bmp/etc when moving position
#BASS_MUSIC_STOPBACK   = $80000   ;stop the music on a backwards jump effect
#BASS_MUSIC_NOSAMPLE   = $100000   ;don't load the samples

;- SPEAKER assignment flags
#BASS_SPEAKER_FRONT      = $01000000            ;front speakers
#BASS_SPEAKER_REAR       = $02000000            ;rear/side speakers
#BASS_SPEAKER_CENLFE     = $03000000            ;center & LFE speakers (5.1)
#BASS_SPEAKER_REAR2      = $04000000            ;rear center speakers (7.1)
Macro BASS_SPEAKER_N(n)   :   (n<<24) :   EndMacro   ;n'th pair of speakers (max 15)
#BASS_SPEAKER_LEFT       = $10000000            ;modifier: left
#BASS_SPEAKER_RIGHT      = $20000000            ;modifier: right
#BASS_SPEAKER_FRONTLEFT  = #BASS_SPEAKER_FRONT | #BASS_SPEAKER_LEFT
#BASS_SPEAKER_FRONTRIGHT = #BASS_SPEAKER_FRONT | #BASS_SPEAKER_RIGHT
#BASS_SPEAKER_REARLEFT   = #BASS_SPEAKER_REAR | #BASS_SPEAKER_LEFT
#BASS_SPEAKER_REARRIGHT  = #BASS_SPEAKER_REAR | #BASS_SPEAKER_RIGHT
#BASS_SPEAKER_CENTER     = #BASS_SPEAKER_CENLFE | #BASS_SPEAKER_LEFT
#BASS_SPEAKER_LFE        = #BASS_SPEAKER_CENLFE | #BASS_SPEAKER_RIGHT
#BASS_SPEAKER_REAR2LEFT  = #BASS_SPEAKER_REAR2 | #BASS_SPEAKER_LEFT
#BASS_SPEAKER_REAR2RIGHT = #BASS_SPEAKER_REAR2 | #BASS_SPEAKER_RIGHT

;- FILE flags
#BASS_ASYNCFILE = $40000000
#BASS_UNICODE = $80000000

;- RECORD flags
#BASS_RECORD_PAUSE      = $8000 ;start recording paused
#BASS_RECORD_ECHOCANCEL   = $2000
#BASS_RECORD_AGC         = $4000

;- DX7 voice allocation & management flags
#BASS_VAM_HARDWARE  = 1
#BASS_VAM_SOFTWARE  = 2
#BASS_VAM_TERM_TIME = 4
#BASS_VAM_TERM_DIST = 8
#BASS_VAM_TERM_PRIO = 16

;- BASS Structures
Structure BASS_CHANNELINFO
   freq.l      ;default playback rate
   chans.l      ;channels
   flags.l      ;BASS_SAMPLE/STREAM/MUSIC/SPEAKER flags
   ctype.l      ;type of channel
   origres.l   ;original resolution
   plugin.l      ;plugin handle
   sample.l      ;sample
   *filename   ;filename
EndStructure

;- BASS_CHANNELINFO types
#BASS_CTYPE_SAMPLE            = 1
#BASS_CTYPE_RECORD            = 2
#BASS_CTYPE_STREAM            = $10000
#BASS_CTYPE_STREAM_OGG         = $10002
#BASS_CTYPE_STREAM_MP1         = $10003
#BASS_CTYPE_STREAM_MP2         = $10004
#BASS_CTYPE_STREAM_MP3         = $10005
#BASS_CTYPE_STREAM_AIFF         = $10006
#BASS_CTYPE_STREAM_CA         = $10007
#BASS_CTYPE_STREAM_MF         = $10008
#BASS_CTYPE_STREAM_WAV         = $40000 ;WAVE flag, LOWORD=codec
#BASS_CTYPE_STREAM_WAV_PCM      = $50001
#BASS_CTYPE_STREAM_WAV_FLOAT   = $50003
#BASS_CTYPE_MUSIC_MOD         = $20000
#BASS_CTYPE_MUSIC_MTM         = $20001
#BASS_CTYPE_MUSIC_S3M         = $20002
#BASS_CTYPE_MUSIC_XM            = $20003
#BASS_CTYPE_MUSIC_IT            = $20004
#BASS_CTYPE_MUSIC_MO3         = $00100 ;MO3 flag

Structure BASS_PLUGINFORM
   ctype.l ;channel type
   *name     ;format description
   *exts     ;file extension filter (*.ext1;*.ext2;etc...)
EndStructure

Structure BASS_PLUGININFO
   version.l ;version (same form as BASS_GetVersion)
   formatc.l ;number of formats
   *formats.BASS_PLUGINFORM ;the array of formats
EndStructure

;- 3D vector (For 3D positions/velocities/orientations)
Structure BASS_3DVECTOR
   x.f ;+=right, -=left
   y.f ;+=up, -=down
   z.f ;+=front, -=behind
EndStructure

;- 3D channel modes
#BASS_3DMODE_NORMAL      = 0 ;normal 3D processing
#BASS_3DMODE_RELATIVE   = 1 ;position is relative to the listener
#BASS_3DMODE_OFF         = 2 ;no 3D processing

;- software 3D mixing algorithms (used With BASS_CONFIG_3DALGORITHM)
#BASS_3DALG_DEFAULT   = 0
#BASS_3DALG_OFF      = 1
#BASS_3DALG_FULL      = 2
#BASS_3DALG_LIGHT      = 3

CompilerIf #PB_Compiler_OS = #PB_OS_Windows
   ;- EAX environments, use With BASS_SetEAXParameters
   Enumeration 0
      #EAX_ENVIRONMENT_GENERIC
      #EAX_ENVIRONMENT_PADDEDCELL
      #EAX_ENVIRONMENT_ROOM
      #EAX_ENVIRONMENT_BATHROOM
      #EAX_ENVIRONMENT_LIVINGROOM
      #EAX_ENVIRONMENT_STONEROOM
      #EAX_ENVIRONMENT_AUDITORIUM
      #EAX_ENVIRONMENT_CONCERTHALL
      #EAX_ENVIRONMENT_CAVE
      #EAX_ENVIRONMENT_ARENA
      #EAX_ENVIRONMENT_HANGAR
      #EAX_ENVIRONMENT_CARPETEDHALLWAY
      #EAX_ENVIRONMENT_HALLWAY
      #EAX_ENVIRONMENT_STONECORRIDOR
      #EAX_ENVIRONMENT_ALLEY
      #EAX_ENVIRONMENT_FOREST
      #EAX_ENVIRONMENT_CITY
      #EAX_ENVIRONMENT_MOUNTAINS
      #EAX_ENVIRONMENT_QUARRY
      #EAX_ENVIRONMENT_PLAIN
      #EAX_ENVIRONMENT_PARKINGLOT
      #EAX_ENVIRONMENT_SEWERPIPE
      #EAX_ENVIRONMENT_UNDERWATER
      #EAX_ENVIRONMENT_DRUGGED
      #EAX_ENVIRONMENT_DIZZY
      #EAX_ENVIRONMENT_PSYCHOTIC
      
      #EAX_ENVIRONMENT_COUNT         ;total number of environments
   EndEnumeration
   
   ;EAX presets, usage: BASS_SetEAXParameters(EAX_PRESET_xxx)
   Macro EAX_PRESET_GENERIC         : #EAX_ENVIRONMENT_GENERIC,0.5F,1.493F,0.5F : EndMacro
   Macro EAX_PRESET_PADDEDCELL      : #EAX_ENVIRONMENT_PADDEDCELL,0.25F,0.1F,0.0F : EndMacro
   Macro EAX_PRESET_ROOM            : #EAX_ENVIRONMENT_ROOM,0.417F,0.4F,0.666F : EndMacro
   Macro EAX_PRESET_BATHROOM        : #EAX_ENVIRONMENT_BATHROOM,0.653F,1.499F,0.166F : EndMacro
   Macro EAX_PRESET_LIVINGROOM      : #EAX_ENVIRONMENT_LIVINGROOM,0.208F,0.478F,0.0F : EndMacro
   Macro EAX_PRESET_STONEROOM       : #EAX_ENVIRONMENT_STONEROOM,0.5F,2.309F,0.888F : EndMacro
   Macro EAX_PRESET_AUDITORIUM      : #EAX_ENVIRONMENT_AUDITORIUM,0.403F,4.279F,0.5F : EndMacro
   Macro EAX_PRESET_CONCERTHALL     : #EAX_ENVIRONMENT_CONCERTHALL,0.5F,3.961F,0.5F : EndMacro
   Macro EAX_PRESET_CAVE            : #EAX_ENVIRONMENT_CAVE,0.5F,2.886F,1.304F : EndMacro
   Macro EAX_PRESET_ARENA           : #EAX_ENVIRONMENT_ARENA,0.361F,7.284F,0.332F : EndMacro
   Macro EAX_PRESET_HANGAR          : #EAX_ENVIRONMENT_HANGAR,0.5F,10.0F,0.3F : EndMacro
   Macro EAX_PRESET_CARPETEDHALLWAY : #EAX_ENVIRONMENT_CARPETEDHALLWAY,0.153F,0.259F,2.0F : EndMacro
   Macro EAX_PRESET_HALLWAY         : #EAX_ENVIRONMENT_HALLWAY,0.361F,1.493F,0.0F : EndMacro
   Macro EAX_PRESET_STONECORRIDOR   : #EAX_ENVIRONMENT_STONECORRIDOR,0.444F,2.697F,0.638F : EndMacro
   Macro EAX_PRESET_ALLEY           : #EAX_ENVIRONMENT_ALLEY,0.25F,1.752F,0.776F : EndMacro
   Macro EAX_PRESET_FOREST          : #EAX_ENVIRONMENT_FOREST,0.111F,3.145F,0.472F : EndMacro
   Macro EAX_PRESET_CITY            : #EAX_ENVIRONMENT_CITY,0.111F,2.767F,0.224F : EndMacro
   Macro EAX_PRESET_MOUNTAINS       : #EAX_ENVIRONMENT_MOUNTAINS,0.194F,7.841F,0.472F : EndMacro
   Macro EAX_PRESET_QUARRY          : #EAX_ENVIRONMENT_QUARRY,1.0F,1.499F,0.5F : EndMacro
   Macro EAX_PRESET_PLAIN           : #EAX_ENVIRONMENT_PLAIN,0.097F,2.767F,0.224F : EndMacro
   Macro EAX_PRESET_PARKINGLOT      : #EAX_ENVIRONMENT_PARKINGLOT,0.208F,1.652F,1.5F : EndMacro
   Macro EAX_PRESET_SEWERPIPE       : #EAX_ENVIRONMENT_SEWERPIPE,0.652F,2.886F,0.25F : EndMacro
   Macro EAX_PRESET_UNDERWATER      : #EAX_ENVIRONMENT_UNDERWATER,1.0F,1.499F,0.0F : EndMacro
   Macro EAX_PRESET_DRUGGED         : #EAX_ENVIRONMENT_DRUGGED,0.875F,8.392F,1.388F : EndMacro
   Macro EAX_PRESET_DIZZY           : #EAX_ENVIRONMENT_DIZZY,0.139F,17.234F,0.666F : EndMacro
   Macro EAX_PRESET_PSYCHOTIC       : #EAX_ENVIRONMENT_PSYCHOTIC,0.486F,7.563F,0.806F : EndMacro
CompilerEndIf

;typedef DWORD (CALLBACK STREAMPROC)(HSTREAM handle, void *buffer, DWORD length, void *user);
; User stream callback function. NOTE: A stream function should obviously be as quick
;as possible, other streams (and MOD musics) can't be mixed until it's finished.
;handle : The stream that needs writing
;buffer : Buffer to write the samples in
;length : Number of bytes to write
;user   : The 'user' parameter value given when calling BASS_StreamCreate
;RETURN : Number of bytes written. Set the BASS_STREAMPROC_END flag to end
;         the stream.

#BASS_STREAMPROC_END   = $80000000   ;end of user stream flag

;- special STREAMPROCs
;#STREAMPROC_DUMMY      (STREAMPROC*)0      // "dummy" stream
;#STREAMPROC_PUSH         (STREAMPROC*)-1      // push stream

;special STREAMPROCs
#STREAMPROC_DUMMY   = 0   ;"dummy" stream
#STREAMPROC_PUSH   = -1   ;push stream

;- BASS_StreamCreateFileUser file systems
#STREAMFILE_NOBUFFER      = 0
#STREAMFILE_BUFFER      = 1
#STREAMFILE_BUFFERPUSH   = 2

;- User file stream callback functions
;typedef void (CALLBACK FILECLOSEPROC)(void *user);
;typedef QWORD (CALLBACK FILELENPROC)(void *user);
;typedef DWORD (CALLBACK FILEREADPROC)(void *buffer, DWORD length, void *user);
;typedef BOOL (CALLBACK FILESEEKPROC)(QWORD offset, void *user);

Structure BASS_FILEPROCS
   *close
   *length
   *read
   *seek
EndStructure

;- BASS_StreamPutFileData options
#BASS_FILEDATA_END      = 0   ;end & close the file

;- BASS_StreamGetFilePosition modes
#BASS_FILEPOS_CURRENT   = 0
#BASS_FILEPOS_DECODE      = #BASS_FILEPOS_CURRENT
#BASS_FILEPOS_DOWNLOAD   = 1
#BASS_FILEPOS_END         = 2
#BASS_FILEPOS_START      = 3
#BASS_FILEPOS_CONNECTED   = 4
#BASS_FILEPOS_BUFFER      = 5
#BASS_FILEPOS_SOCKET      = 6
#BASS_FILEPOS_ASYNCBUF   = 7
#BASS_FILEPOS_SIZE      = 8

;typedef void (CALLBACK DOWNLOADPROC)(const void *buffer, DWORD length, void *user);
;/* Internet stream download callback function.
;buffer : Buffer containing the downloaded data... NULL=end of download
;length : Number of bytes in the buffer
;user   : The 'user' parameter value given when calling BASS_StreamCreateURL */

;- BASS_ChannelSetSync types
#BASS_SYNC_POS            = 0
#BASS_SYNC_END            = 2
#BASS_SYNC_META         = 4
#BASS_SYNC_SLIDE         = 5
#BASS_SYNC_STALL         = 6
#BASS_SYNC_DOWNLOAD      = 7
#BASS_SYNC_FREE         = 8
#BASS_SYNC_SETPOS         = 11
#BASS_SYNC_MUSICPOS      = 10
#BASS_SYNC_MUSICINST      = 1
#BASS_SYNC_MUSICFX      = 3
#BASS_SYNC_OGG_CHANGE   = 12
#BASS_SYNC_MIXTIME      = $40000000   ;FLAG: sync at mixtime, else at playtime
#BASS_SYNC_ONETIME      = $80000000   ;FLAG: sync only once, else continuously

;typedef void (CALLBACK SYNCPROC)(HSYNC handle, DWORD channel, DWORD data, void *user);
;Sync callback function. NOTE: a sync callback function should be very
;quick as other syncs can't be processed until it has finished. If the sync
;is a "mixtime" sync, then other streams and MOD musics can't be mixed until
;it's finished either.
;handle : The sync that has occured
;channel: Channel that the sync occured in
;data   : Additional data associated with the sync's occurance
;user   : The 'user' parameter given when calling BASS_ChannelSetSync */

;typedef void (CALLBACK DSPPROC)(HDSP handle, DWORD channel, void *buffer, DWORD length, void *user);
;/* DSP callback function. NOTE: A DSP function should obviously be as quick as
;possible... other DSP functions, streams and MOD musics can not be processed
;until it's finished.
;handle : The DSP handle
;channel: Channel that the DSP is being applied to
;buffer : Buffer to apply the DSP to
;length : Number of bytes in the buffer
;user   : The 'user' parameter given when calling BASS_ChannelSetDSP */

;typedef BOOL (CALLBACK RECORDPROC)(HRECORD handle, const void *buffer, DWORD length, void *user);
;/* Recording callback function.
;handle : The recording handle
;buffer : Buffer containing the recorded sample data
;length : Number of bytes
;user   : The 'user' parameter value given when calling BASS_RecordStart
;RETURN : TRUE = continue recording, FALSE = stop */

;- BASS_ChannelIsActive Return values
#BASS_ACTIVE_STOPPED   = 0
#BASS_ACTIVE_PLAYING   = 1
#BASS_ACTIVE_STALLED   = 2
#BASS_ACTIVE_PAUSED   = 3

;- Channel attributes
#BASS_ATTRIB_FREQ               = 1
#BASS_ATTRIB_VOL               = 2
#BASS_ATTRIB_PAN               = 3
#BASS_ATTRIB_EAXMIX            = 4
#BASS_ATTRIB_NOBUFFER         = 5
#BASS_ATTRIB_VBR               = 6
#BASS_ATTRIB_CPU               = 7
#BASS_ATTRIB_SRC               = 8
#BASS_ATTRIB_NET_RESUME         = 9
#BASS_ATTRIB_SCANINFO         = 10
#BASS_ATTRIB_MUSIC_AMPLIFY      = $100
#BASS_ATTRIB_MUSIC_PANSEP      = $101
#BASS_ATTRIB_MUSIC_PSCALER      = $102
#BASS_ATTRIB_MUSIC_BPM         = $103
#BASS_ATTRIB_MUSIC_SPEED      = $104
#BASS_ATTRIB_MUSIC_VOL_GLOBAL   = $105
#BASS_ATTRIB_MUSIC_ACTIVE      = $106
#BASS_ATTRIB_MUSIC_VOL_CHAN   = $200   ;+ channel #
#BASS_ATTRIB_MUSIC_VOL_INST   = $300   ;+ instrument #

;- BASS_ChannelGetData flags
#BASS_DATA_AVAILABLE         = 0         ;query how much data is buffered
#BASS_DATA_FIXED            = $20000000   ;flag: return 8.24 fixed-point data
#BASS_DATA_FLOAT            = $40000000   ;flag: return floating-point sample data
#BASS_DATA_FFT256            = $80000000   ;256 sample FFT
#BASS_DATA_FFT512            = $80000001   ;512 FFT
#BASS_DATA_FFT1024         = $80000002   ;1024 FFT
#BASS_DATA_FFT2048         = $80000003   ;2048 FFT
#BASS_DATA_FFT4096         = $80000004   ;4096 FFT
#BASS_DATA_FFT8192         = $80000005   ;8192 FFT
#BASS_DATA_FFT16384         = $80000006   ;16384 FFT
#BASS_DATA_FFT_INDIVIDUAL   = $10         ;FFT flag: FFT for each channel, else all combined
#BASS_DATA_FFT_NOWINDOW      = $20         ;FFT flag: no Hanning window
#BASS_DATA_FFT_REMOVEDC      = $40         ;FFT flag: pre-remove DC bias
#BASS_DATA_FFT_COMPLEX      = $80         ;FFT flag: return complex data

;- BASS_ChannelGetTags types : what's returned
#BASS_TAG_ID3               = 0      ;ID3v1 tags : TAG_ID3 structure
#BASS_TAG_ID3V2            = 1      ;ID3v2 tags : variable length block
#BASS_TAG_OGG               = 2      ;OGG comments : series of null-terminated UTF-8 strings
#BASS_TAG_HTTP               = 3      ;HTTP headers : series of null-terminated ANSI strings
#BASS_TAG_ICY               = 4      ;ICY headers : series of null-terminated ANSI strings
#BASS_TAG_META               = 5      ;ICY metadata : ANSI string
#BASS_TAG_APE               = 6      ;APE tags : series of null-terminated UTF-8 strings
#BASS_TAG_MP4               = 7      ;MP4/iTunes metadata : series of null-terminated UTF-8 strings
#BASS_TAG_VENDOR            = 9      ;OGG encoder : UTF-8 string
#BASS_TAG_LYRICS3            = 10      ;Lyric3v2 tag : ASCII string
#BASS_TAG_CA_CODEC         = 11      ;CoreAudio codec info : TAG_CA_CODEC structure
#BASS_TAG_MF               = 13      ;Media Foundation tags : series of null-terminated UTF-8 strings
#BASS_TAG_WAVEFORMAT         = 14      ;WAVE format : WAVEFORMATEEX structure
#BASS_TAG_RIFF_INFO         = $100   ;RIFF "INFO" tags : series of null-terminated ANSI strings
#BASS_TAG_RIFF_BEXT         = $101   ;RIFF/BWF "bext" tags : TAG_BEXT structure
#BASS_TAG_RIFF_CART         = $102   ;RIFF/BWF "cart" tags : TAG_CART structure
#BASS_TAG_RIFF_DISP         = $103   ;RIFF "DISP" text tag : ANSI string
#BASS_TAG_APE_BINARY         = $1000   ;+ index #, binary APE tag : TAG_APE_BINARY structure
#BASS_TAG_MUSIC_NAME         = $10000   ;MOD music name : ANSI string
#BASS_TAG_MUSIC_MESSAGE      = $10001   ;MOD message : ANSI string
#BASS_TAG_MUSIC_ORDERS      = $10002   ;MOD order list : BYTE array of pattern numbers
#BASS_TAG_MUSIC_INST         = $10100   ;+ instrument #, MOD instrument name : ANSI string
#BASS_TAG_MUSIC_SAMPLE      = $10300   ;+ sample #, MOD sample name : ANSI string

;- ID3v1 tag structure
Structure TAG_ID3
   id.a[3]
   title.a[30]
   artist.a[30]
   album.a[30]
   year.a[4]
   comment.a[30]
   genre.b
EndStructure

;- Binary APE tag structure
Structure TAG_APE_BINARY
   *key
   *data
   length.l
EndStructure

;- BWF "bext" tag structure
Structure TAG_BEXT
   Description.a[256]         ;// description
   Originator.a[32]            ;// name of the originator
   OriginatorReference.a[32]   ;// reference of the originator
   OriginationDate.a[10]      ;// date of creation (yyyy-mm-dd)
   OriginationTime.a[8]         ;// time of creation (hh-mm-ss)
   TimeReference.q            ;// first sample count since midnight (little-endian)
   Version.w                  ;// BWF version (little-endian)
   UMID.b[64]                  ;// SMPTE UMID
   Reserved.b[190]
   CodingHistory.a[0]         ;// history
EndStructure

;- BWF "cart" tag structures
Structure TAG_CART_TIMER
   dwUsage.l ;FOURCC timer usage ID
   dwValue.l ;timer value in samples from head
EndStructure

Structure TAG_CART
   Version.a[4]            ;version of the data structure
   Title.a[64]               ;title of cart audio sequence
   Artist.a[64]            ;artist or creator name
   CutID.a[64]               ;cut number identification
   ClientID.a[64]            ;client identification
   Category.a[64]            ;category ID, PSA, NEWS, etc
   Classification.a[64]      ;classification or auxiliary key
   OutCue.a[64]            ;out cue text
   StartDate.a[10]         ;yyyy-mm-dd
   StartTime.a[8]            ;hh:mm:ss
   EndDate.a[10]            ;yyyy-mm-dd
   EndTime.a[8]            ;hh:mm:ss
   ProducerAppID.a[64]      ;name of vendor or application
   ProducerAppVersion.a[64];version of producer application
   UserDef.a[64]            ;user defined text
   dwLevelReference.l      ;sample value for 0 dB reference
   PostTimer.TAG_CART_TIMER[8]   ;8 time markers after head
   Reserved.a[276]
   URL.a[1024]               ;uniform resource locator
   TagText.a[0]            ;free form text for scripts or tags
EndStructure

;CoreAudio codec info structure
Structure TAG_CA_CODEC
   ftype.l               ;file format
   atype.l               ;audio format
   *name                  ;description
EndStructure

CompilerIf Defined(WAVEFORMATEX, #PB_Structure) = #False
   Structure WAVEFORMATEX
      wFormatTag.u
      nChannels.u
      nSamplesPerSec.l
      nAvgBytesPerSec.l
      nBlockAlign.u
      wBitsPerSample.u
      cbSize.u
   EndStructure
CompilerEndIf

;- BASS_ChannelGetLength/GetPosition/SetPosition modes
#BASS_POS_BYTE            = 0         ;byte position
#BASS_POS_MUSIC_ORDER   = 1         ;order.row position, MAKELONG(order,row)
#BASS_POS_OGG            = 3         ;OGG bitstream number
#BASS_POS_INEXACT         = $08000000   ;flag: allow seeking to inexact position
#BASS_POS_DECODE         = $10000000   ;flag: get the decoding (not playing) position
#BASS_POS_DECODETO      = $20000000   ;flag: decode to the position instead of seeking
#BASS_POS_SCAN            = $40000000   ;flag: scan to the position

;- BASS_RecordSetInput flags
#BASS_INPUT_OFF   = $10000
#BASS_INPUT_ON      = $20000

#BASS_INPUT_TYPE_MASK      = $ff000000
#BASS_INPUT_TYPE_UNDEF      = $00000000
#BASS_INPUT_TYPE_DIGITAL   = $01000000
#BASS_INPUT_TYPE_LINE      = $02000000
#BASS_INPUT_TYPE_MIC         = $03000000
#BASS_INPUT_TYPE_SYNTH      = $04000000
#BASS_INPUT_TYPE_CD         = $05000000
#BASS_INPUT_TYPE_PHONE      = $06000000
#BASS_INPUT_TYPE_SPEAKER   = $07000000
#BASS_INPUT_TYPE_WAVE      = $08000000
#BASS_INPUT_TYPE_AUX         = $09000000
#BASS_INPUT_TYPE_ANALOG      = $0a000000

;DX8 effect types, use with BASS_ChannelSetFX
Enumeration 0
   #BASS_FX_DX8_CHORUS
   #BASS_FX_DX8_COMPRESSOR
   #BASS_FX_DX8_DISTORTION
   #BASS_FX_DX8_ECHO
   #BASS_FX_DX8_FLANGER
   #BASS_FX_DX8_GARGLE
   #BASS_FX_DX8_I3DL2REVERB
   #BASS_FX_DX8_PARAMEQ
   #BASS_FX_DX8_REVERB
EndEnumeration

Structure BASS_DX8_CHORUS
   fWetDryMix.f
   fDepth.f
   fFeedback.f
   fFrequency.f
   lWaveform.l  ;0=triangle, 1=sine
   fDelay.f
   lPhase.l     ;BASS_DX8_PHASE_xxx
EndStructure

Structure BASS_DX8_COMPRESSOR
   fGain.f
   fAttack.f
   fRelease.f
   fThreshold.f
   fRatio.f
   fPredelay.f
EndStructure

Structure BASS_DX8_DISTORTION
   fGain.f
   fEdge.f
   fPostEQCenterFrequency.f
   fPostEQBandwidth.f
   fPreLowpassCutoff.f
EndStructure

Structure BASS_DX8_ECHO
   fWetDryMix.f
   fFeedback.f
   fLeftDelay.f
   fRightDelay.f
   lPanDelay.l
EndStructure

Structure BASS_DX8_FLANGER
   fWetDryMix.f
   fDepth.f
   fFeedback.f
   fFrequency.f
   lWaveform.l   ;0=triangle, 1=sine
   fDelay.f
   lPhase.l        ;BASS_DX8_PHASE_xxx
EndStructure

Structure BASS_DX8_GARGLE
   dwRateHz.l    ;Rate of modulation in hz
   dwWaveShape.l ;0=triangle, 1=square
EndStructure

Structure BASS_DX8_I3DL2REVERB
   lRoom.l               ;[-10000, 0]      default: -1000 mB
   lRoomHF.l             ;[-10000, 0]      default: 0 mB
   flRoomRolloffFactor.f ;[0.0, 10.0]      default: 0.0
   flDecayTime.f          ;[0.1, 20.0]      default: 1.49s
   flDecayHFRatio.f       ;[0.1, 2.0]      default: 0.83
   lReflections.l          ;[-10000, 1000]   default: -2602 mB
   flReflectionsDelay.f    ;[0.0, 0.3]      default: 0.007 s
   lReverb.l             ;[-10000, 2000]   default: 200 mB
   flReverbDelay.f       ;[0.0, 0.1]      default: 0.011 s
   flDiffusion.f          ;[0.0, 100.0]      default: 100.0 %
   flDensity.f             ;[0.0, 100.0]      default: 100.0 %
   flHFReference.f       ;[20.0, 20000.0]   default: 5000.0 Hz
EndStructure

Structure BASS_DX8_PARAMEQ
   fCenter.f
   fBandwidth.f
   fGain.f
EndStructure

Structure BASS_DX8_REVERB
   fInGain.f          ;[-96.0,0.0]      default: 0.0 dB
   fReverbMix.f       ;[-96.0,0.0]      default: 0.0 db
   fReverbTime.f       ;[0.001,3000.0]   default: 1000.0 ms
   fHighFreqRTRatio.f ;[0.001,0.999]   default: 0.001
EndStructure

#BASS_DX8_PHASE_NEG_180   = 0
#BASS_DX8_PHASE_NEG_90   = 1
#BASS_DX8_PHASE_ZERO      = 2
#BASS_DX8_PHASE_90      = 3
#BASS_DX8_PHASE_180      = 4

; typedef void (CALLBACK IOSNOTIFYPROC)(DWORD status);
; /* iOS notification callback function.
; status : The notification (BASS_IOSNOTIFY_xxx) */

#BASS_IOSNOTIFY_INTERRUPT      = 1   ;interruption started
#BASS_IOSNOTIFY_INTERRUPT_END   = 2   ;interruption ended

ImportC "bass.lib"
  BASS_SetConfig.l(option.l, value.l)
  BASS_GetConfig(option.l)
  BASS_SetConfigPtr.l(option.l, *value)
  BASS_GetConfigPtr.i(option.l)
  BASS_GetVersion.l()
  BASS_ErrorGetCode.l()
  BASS_GetDeviceInfo.l(device.l, *info)
  BASS_Init.l(device.l, freq.l, flags.l, *win, *dsguid)
  BASS_SetDevice.l(device.l)
  BASS_GetDevice.l()
  BASS_Free.l()
  BASS_GetDSoundObject.i(object.l)
  BASS_GetInfo.l(*info)
  BASS_Update.l(length.l)
  BASS_GetCPU.f()
  BASS_Start.l()
  BASS_Stop.l()
  BASS_Pause.l()
  BASS_SetVolume.l(volume.f)
  BASS_GetVolume.f()
  BASS_PluginLoad.l(*file, flags.l)
  BASS_PluginFree.l(handle.l)
  BASS_PluginGetInfo.i(handle.l)
  BASS_Set3DFactors.l(distf.f, rollf.f, doppf.f)
  BASS_Get3DFactors.l(*distf, *rollf, *doppf)
  BASS_Set3DPosition.l(*pos, *vel, *front, *top)
  BASS_Get3DPosition.l(*pos, *vel, *front, *top)
  BASS_Apply3D.i()
  BASS_SetEAXParameters.l(env.l, vol.f, decay.f, damp.f)
  BASS_GetEAXParameters.l(*env, *vol, *decay, *damp)
  BASS_MusicLoad.l(mem.l, *file, offset.q, length.l, flags.l, freq.l)
  BASS_MusicFree.l(handle.l)
  BASS_SampleLoad.l(mem.l, *file, offset.q, length.l, max.l, flags.l)
  BASS_SampleCreate.l(length.l, freq.l, chans.l, max.l, flags.l)
  BASS_SampleFree.l(handle.l)
  BASS_SampleSetData.l(handle.l, *buffer)
  BASS_SampleGetData.l(handle.l, *buffer)
  BASS_SampleGetInfo.l(handle.l, *info)
  BASS_SampleSetInfo.l(handle.l, *info)
  BASS_SampleGetChannel.l(handle.l, onlynew.l)
  BASS_SampleGetChannels.l(handle.l, *channels)
  BASS_SampleStop.l(handle.l)
  BASS_StreamCreate.l(freq.l, chans.l, flags.l, *proc, *user)
  BASS_StreamCreateFile.l(mem.l, *file, offset.q, length.q, flags.l)
  BASS_StreamCreateURL.l(*url, offset.l, flags.l, *proc, *user)
  BASS_StreamCreateFileUser.l(system.l, flags.l, *proc, *user)
  BASS_StreamFree.l(handle.l)
  BASS_StreamGetFilePosition.q(handle.l, mode.l)
  BASS_StreamPutData.l(handle.l, *buffer, length.l)
  BASS_StreamPutFileData.l(handle.l, *buffer, length.l)
  BASS_RecordGetDeviceInfo.l(device.l, *info)
  BASS_RecordInit.l(device.l)
  BASS_RecordSetDevice.l(device.l)
  BASS_RecordGetDevice.l()
  BASS_RecordFree.l()
  BASS_RecordGetInfo.l(*info)
  BASS_RecordGetInputName.i(input.l)
  BASS_RecordSetInput.l(input.l, flags.l, volume.f)
  BASS_RecordGetInput.l(input.l, *volume)
  BASS_RecordStart.l(freq.l, chans.l, flags.l, *proc, *user)
  BASS_ChannelBytes2Seconds.d(handle.l, pos.q)
  BASS_ChannelSeconds2Bytes.q(handle.l, pos.d)
  BASS_ChannelGetDevice.l(handle.l)
  BASS_ChannelSetDevice.l(handle.l, device.l)
  BASS_ChannelIsActive.l(handle.l)
  BASS_ChannelGetInfo.l(handle.l, *info)
  BASS_ChannelGetTags.i(handle.l, tags.l)
  BASS_ChannelFlags.l(handle.l, flags.l, mask.l)
  BASS_ChannelUpdate.l(handle.l, length.l)
  BASS_ChannelLock.l(handle.l, lock.l)
  BASS_ChannelPlay.l(handle.l, restart.l)
  BASS_ChannelStop.l(handle.l)
  BASS_ChannelPause.l(handle.l)
  BASS_ChannelSetAttribute.l(handle.l, attrib.l, value.f)
  BASS_ChannelGetAttribute.l(handle.l, attrib.l, *value)
  BASS_ChannelSlideAttribute.l(handle.l, attrib.l, value.f, time.l)
  BASS_ChannelIsSliding(handle.l, attrib.l)
  BASS_ChannelSetAttributeEx.l(handle.l, attrib.l, *value, size.l)
  BASS_ChannelGetAttributeEx.l(handle.l, attrib.l, *value, size.l)
  BASS_ChannelSet3DAttributes.l(handle.l, mode.l, min.f, max.f, iangle.l, oangle.l, outvol.f)
  BASS_ChannelGet3DAttributes.l(handle.l, *mode, *min, *max, *iangle, *oangle, *outvol)
  BASS_ChannelSet3DPosition.l(handle.l, *pos, *orient, *vel)
  BASS_ChannelGet3DPosition.l(handle.l, *pos, *orient, *vel)
  BASS_ChannelGetLength.q(handle.l, mode.l)
  BASS_ChannelSetPosition.l(handle.l, pos.q, mode.l)
  BASS_ChannelGetPosition.q(handle.l, mode.l)
  BASS_ChannelGetLevel.l(handle.l)
  BASS_ChannelGetLevelEx.l(handle.l, *levels, length.f, flags.l)
  BASS_ChannelGetData.l(handle.l, *buffer, length.l)
  BASS_ChannelSetSync.l(handle.l, type.l, param.q, *proc, *user)
  BASS_ChannelRemoveSync.l(handle.l, sync.l)
  BASS_ChannelSetDSP.l(handle.l, *proc, *user, priority.l)
  BASS_ChannelRemoveDSP.l(handle.l, dsp.l)
  BASS_ChannelSetLink.l(handle.l, chan.l)
  BASS_ChannelRemoveLink.l(handle.l, chan.l)
  BASS_ChannelSetFX.l(handle.l, type.l, priority.l)
  BASS_ChannelRemoveFX.l(handle.l, fx.l)
  BASS_FXSetParameters.l(handle.l, *params)
  BASS_FXGetParameters.l(handle.l, *params)
  BASS_FXReset.l(handle.l)
EndImport

Viel Spaß :D

Was ich noch nicht ganz verstehe - es gibt ja eine x86 & x64 Version von bass aber nur eine (PureBasic) 'Header-Datei' !
Bleiben alle Variablen (der Funktionen) und Strukturen gleich ?


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 18.01.2019 19:44 
Offline

Registriert: 27.11.2016 18:13
Wohnort: Erzgebirge
Hi Mijikai !

Mijikai hat geschrieben:
Was ich noch nicht ganz verstehe - es gibt ja eine x86 & x64 Version von bass aber nur eine (PureBasic) 'Header-Datei' !
Bleiben alle Variablen (der Funktionen) und Strukturen gleich ?


Es scheint so.

Also bei der Bass-Include die ich nutze werden eigentlich keine 64 bit Integer, oder andere Speicherfallstricke benutzt.
Auch bei z.B. "Version.a[4]", etc. wurde immer schön auf Kompatibilität geachtet.

Außerdem gibt es ja eine 32 bit bass.dll und eine 64 bit bass.dll .

Und per Standard arbeitet die bass.dll im Ascii-Modus.

Der Unicode-Modus muss erst aktiviert werden. (Dies ist bei heutigen Dateinamen aber dringend empfohlen.)


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 19.01.2019 11:42 
Offline
Benutzeravatar

Registriert: 25.09.2016 01:42
@ccode_new danke für die Infos :)
Bass sieht scheint eine gute Sound-Library zu sein.
Werde ich mal ausprobieren (bin ein kompletter Neuling was Soundzeugs angeht).


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 19.01.2019 12:44 
Offline
Benutzeravatar

Registriert: 06.09.2004 13:27
Man muss aber auch zugeben, dass die Standard MOVIE Behandlung nicht sonderlich gut ist und man deshalb auf was anderes umsteigen sollte. BASS oder FMOD sind da schon toll und umfangreich, aber die Dokumentation ist schon sehr speziell und für Anfänger kaum zu verstehen. :?

Dieser Code von ccode_new ist schon gut, aber ich habe damit auch nur 2 kleine Linien, welche kaum Ausschlag anzeigen. So wie ich die Sache hier verstanden habe, benötigte THEN ja auch keine PBI oder DLL, die muss er ja schon gehabt haben, sonst könnte er ja die Codes nicht testen. Ich denke, ihm geht's wie anderen auch, dass diese BASS schon recht umfangreich und schwer zu verstehen ist.

Ich bastle auch mal herum, denn ein vernünftiges Beispiel für die verschiedenen BASS Funktionen ist mit Sicherheit hilfreich für jeden, der mit Sounds und MP3s arbeiten möchte :allright:

BTW : Selbst der oben stehende Code von CCODE_NEW funktioniert so nicht und bringt Anfänger zur Verzweiflung. Da ist weder was von der BASS.DLL (Load) oder BASS.PBI (Include) drin. Auch etwas, was hier nicht so ganz befriedigend ist. Hier sind laufend nur Codeschnipsel zu finden, die man erst wieder mühevoll zusammensuchen muss. Warum nicht einen Lauffähigen Code ? Im Archiv ist doch auch alles (soweit) lauffähig. :|


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 19.01.2019 13:23 
Offline
Benutzeravatar

Registriert: 06.09.2004 13:26
Wohnort: Siegen
@Mauli: Was vergessenw urde zu erwähnen (scheint ja nicht wichtig zu sein) ist, dass du PB 5.62 nehmen musst. Habs mit 5.60 getestet und da ging es nicht..... dünne Linien, warum auch immer.

_________________
PB 5.62 / Windows 10 64Bit (i5/32GB/240GBSSD+2TBHDD/960GTX4GB) / 27" Multitouch Monitor

... ich mache dazu keine Aussage, weil ich mich damit selbst belasten könnte !


Nach oben
 Profil  
Mit Zitat antworten  
 Betreff des Beitrags: Re: MP3 als Waveform anzeigen
BeitragVerfasst: 19.01.2019 13:51 
Offline

Registriert: 27.11.2016 18:13
Wohnort: Erzgebirge
Hallo liebe BASS-Freunde.

Hier einmal noch eine kleine Demo. (Ähnlich der bei der bass-Lib beiliegenden "spectrum.c"-Datei.)

Code:
EnableExplicit

IncludeFile "bass.pbi"

;- Prototype Macros
Macro GetFunctionProtoQuote
  "
EndMacro
Macro GetFunctionProto(dll, name)
  Global name.name
  name = GetFunction(dll, GetFunctionProtoQuote#name#GetFunctionProtoQuote)
  CompilerIf #PB_Compiler_Debugger  ; Only enable assert in debug mode
    If name = #Null
      Debug "Assert on line " + #PB_Compiler_Line + ", GetFunction(" + GetFunctionProtoQuote#dll#GetFunctionProtoQuote + ", " + GetFunctionProtoQuote#name#GetFunctionProtoQuote + ")"
    EndIf
  CompilerEndIf
EndMacro

; BASS_Load_Library
Threaded _BASS_Load_Library_DLL_.i

Procedure BASS_Free_Library()
  If IsLibrary(_BASS_Load_Library_DLL_)
    CloseLibrary(_BASS_Load_Library_DLL_)
  EndIf
EndProcedure


Procedure.i BASS_Load_Library(dllpath$)
  Protected dll.i, result.i
 
  If IsLibrary(_BASS_Load_Library_DLL_)
    ProcedureReturn #False
  EndIf
 
  _BASS_Load_Library_DLL_ = OpenLibrary(#PB_Any, dllpath$)
  dll = _BASS_Load_Library_DLL_
  If IsLibrary(dll) = #False
   
    ProcedureReturn #False
  EndIf
 
  GetFunctionProto(dll, BASS_GetVersion)
  If BASS_GetVersion = #Null
    ;BASS_GetVersion() not found, is this really bass.dll ?
    BASS_Free_Library()
   
    ProcedureReturn #False
  EndIf
 
  ;Make sure BASS API and bass.dll are compatible.
  result = BASS_GetVersion()
  If (result & $FFFF0000) <> (#BASSVERSION & $FFFF0000) Or (result < #BASSVERSION)
    BASS_Free_Library()
   
    ProcedureReturn #False
  EndIf
 
  ;you should only use the GetFunctionProto() for the BASS functions you actually need/use,
  ;these are macros thus you will save some memory/exe size by removing the functions you don't use,
  ;during debugging the GetFunctionProto() macro will also check if the BASS function exists in the loaded library to catch wrong library versions.
  GetFunctionProto(dll, BASS_SetConfig)
  GetFunctionProto(dll, BASS_GetConfig)
  GetFunctionProto(dll, BASS_SetConfigPtr)
  GetFunctionProto(dll, BASS_GetConfigPtr)
  GetFunctionProto(dll, BASS_ErrorGetCode)
  GetFunctionProto(dll, BASS_GetDeviceInfo)
  GetFunctionProto(dll, BASS_Init)
  GetFunctionProto(dll, BASS_SetDevice)
  GetFunctionProto(dll, BASS_GetDevice)
  GetFunctionProto(dll, BASS_Free)
  ;GetFunctionProto(dll, BASS_GetDSoundObject)
  GetFunctionProto(dll, BASS_GetInfo)
  GetFunctionProto(dll, BASS_Update)
  GetFunctionProto(dll, BASS_GetCPU)
  GetFunctionProto(dll, BASS_Start)
  GetFunctionProto(dll, BASS_Stop)
  GetFunctionProto(dll, BASS_Pause)
  GetFunctionProto(dll, BASS_SetVolume)
  GetFunctionProto(dll, BASS_GetVolume)
 
  GetFunctionProto(dll, BASS_PluginLoad)
  GetFunctionProto(dll, BASS_PluginFree)
  GetFunctionProto(dll, BASS_PluginGetInfo)
 
  GetFunctionProto(dll, BASS_Set3DFactors)
  GetFunctionProto(dll, BASS_Get3DFactors)
  GetFunctionProto(dll, BASS_Set3DPosition)
  GetFunctionProto(dll, BASS_Get3DPosition)
  GetFunctionProto(dll, BASS_Apply3D)
  CompilerIf #PB_Compiler_OS = #PB_OS_Windows
    GetFunctionProto(dll, BASS_SetEAXParameters)
    GetFunctionProto(dll, BASS_GetEAXParameters)
  CompilerEndIf
 
  GetFunctionProto(dll, BASS_MusicLoad)
  GetFunctionProto(dll, BASS_MusicFree)
 
  GetFunctionProto(dll, BASS_SampleLoad)
  GetFunctionProto(dll, BASS_SampleCreate)
  GetFunctionProto(dll, BASS_SampleFree)
  GetFunctionProto(dll, BASS_SampleSetData)
  GetFunctionProto(dll, BASS_SampleGetData)
  GetFunctionProto(dll, BASS_SampleGetInfo)
  GetFunctionProto(dll, BASS_SampleSetInfo)
  GetFunctionProto(dll, BASS_SampleGetChannel)
  GetFunctionProto(dll, BASS_SampleGetChannels)
  GetFunctionProto(dll, BASS_SampleStop)
 
  GetFunctionProto(dll, BASS_StreamCreate)
  GetFunctionProto(dll, BASS_StreamCreateFile)
  GetFunctionProto(dll, BASS_StreamCreateURL)
  GetFunctionProto(dll, BASS_StreamCreateFileUser)
  GetFunctionProto(dll, BASS_StreamFree)
  GetFunctionProto(dll, BASS_StreamGetFilePosition)
  GetFunctionProto(dll, BASS_StreamPutData)
  GetFunctionProto(dll, BASS_StreamPutFileData)
 
  GetFunctionProto(dll, BASS_RecordGetDeviceInfo)
  GetFunctionProto(dll, BASS_RecordInit)
  GetFunctionProto(dll, BASS_RecordSetDevice)
  GetFunctionProto(dll, BASS_RecordGetDevice)
  GetFunctionProto(dll, BASS_RecordFree)
  GetFunctionProto(dll, BASS_RecordGetInfo)
  GetFunctionProto(dll, BASS_RecordGetInputName)
  GetFunctionProto(dll, BASS_RecordSetInput)
  GetFunctionProto(dll, BASS_RecordGetInput)
  GetFunctionProto(dll, BASS_RecordStart)
 
  GetFunctionProto(dll, BASS_ChannelBytes2Seconds)
  GetFunctionProto(dll, BASS_ChannelSeconds2Bytes)
  GetFunctionProto(dll, BASS_ChannelGetDevice)
  GetFunctionProto(dll, BASS_ChannelSetDevice)
  GetFunctionProto(dll, BASS_ChannelIsActive)
  GetFunctionProto(dll, BASS_ChannelGetInfo)
  GetFunctionProto(dll, BASS_ChannelGetTags)
  GetFunctionProto(dll, BASS_ChannelFlags)
  GetFunctionProto(dll, BASS_ChannelUpdate)
  GetFunctionProto(dll, BASS_ChannelLock)
  GetFunctionProto(dll, BASS_ChannelPlay)
  GetFunctionProto(dll, BASS_ChannelStop)
  GetFunctionProto(dll, BASS_ChannelPause)
  GetFunctionProto(dll, BASS_ChannelSetAttribute)
  GetFunctionProto(dll, BASS_ChannelSetAttributeEx)
  GetFunctionProto(dll, BASS_ChannelGetAttribute)
  GetFunctionProto(dll, BASS_ChannelGetAttributeEx)
  GetFunctionProto(dll, BASS_ChannelSlideAttribute)
  GetFunctionProto(dll, BASS_ChannelIsSliding)
  GetFunctionProto(dll, BASS_ChannelSet3DAttributes)
  GetFunctionProto(dll, BASS_ChannelGet3DAttributes)
  GetFunctionProto(dll, BASS_ChannelSet3DPosition)
  GetFunctionProto(dll, BASS_ChannelGet3DPosition)
  GetFunctionProto(dll, BASS_ChannelGetLength)
  GetFunctionProto(dll, BASS_ChannelSetPosition)
  GetFunctionProto(dll, BASS_ChannelGetPosition)
  GetFunctionProto(dll, BASS_ChannelGetLevel)
  GetFunctionProto(dll, BASS_ChannelGetLevelEx)
  GetFunctionProto(dll, BASS_ChannelGetData)
  GetFunctionProto(dll, BASS_ChannelSetSync)
  GetFunctionProto(dll, BASS_ChannelRemoveSync)
  GetFunctionProto(dll, BASS_ChannelSetDSP)
  GetFunctionProto(dll, BASS_ChannelRemoveDSP)
  GetFunctionProto(dll, BASS_ChannelSetLink)
  GetFunctionProto(dll, BASS_ChannelRemoveLink)
  GetFunctionProto(dll, BASS_ChannelSetFX)
  GetFunctionProto(dll, BASS_ChannelRemoveFX)
 
  GetFunctionProto(dll, BASS_FXSetParameters)
  GetFunctionProto(dll, BASS_FXGetParameters)
  GetFunctionProto(dll, BASS_FXReset)
  ProcedureReturn #True
EndProcedure

CompilerIf #PB_Compiler_OS = #PB_OS_Windows
  If BASS_Load_Library("bass.dll") = #False
    Debug "Die bass.dll kann nicht geladen werden."
    End
  EndIf
CompilerElseIf #PB_Compiler_OS = #PB_OS_Linux
  If BASS_Load_Library("libbass.so") = #False
    Debug "Die libbass.so kann nicht geladen werden."
    End
  EndIf
CompilerEndIf

CompilerIf #PB_Compiler_Unicode
  #UNICODE=#BASS_Unicode
CompilerElse
  #UNICODE=#0
CompilerEndIf

Global Handle
Global Event

Global FileName.s = ""

Global cav, tracki, info, epos, tbp

Global active.b = #False

#SPECWIDTH = 368
#SPECHEIGHT = 127
#TIME_PERIODIC = 1
#MainWin=0

Global specpos = 0, specmode = 1

Enumeration
  #BG_Play
  #BG_Pause
  #BG_Stop
  #BG_Load
  #BG_Next
EndEnumeration

Procedure IIF(expr,y,n)
  If expr
    ProcedureReturn y
  Else
    ProcedureReturn n
  EndIf
EndProcedure

Procedure UpdateSpectrum()
  Protected x.l, y.l, y1.l
  Protected ind.l, w.l, v.l, p.q, u.q, k.q
  Protected Dim FFT.f(1024)
  Protected Dim specbuf.l(#SPECWIDTH * (#SPECHEIGHT + 1))
 
  BASS_ChannelGetData(Handle,@FFT(),#BASS_DATA_FFT2048)
 
  StartDrawing(CanvasOutput(cav))
  Box(0, 0, #SPECWIDTH, #SPECHEIGHT, RGB(255,255,255))
 
  Select specmode
    Case 0
      For x = 0 To (#SPECWIDTH/2)-1
        y = #SPECHEIGHT - ((Sqr(fft(x + 1)) * 3 * #SPECHEIGHT)-4) ;  scale it (sqrt to make low values more visible)
                                                                  ;y = #SPECHEIGHT - (fft(x + 1) * 10 * #SPECHEIGHT) ; scale it (linearly)
        If y>#SPECHEIGHT : y=#SPECHEIGHT : EndIf
        If x
          y1 = (y + y1) / 2
          y1 = y1 + 1
          While (y1 >= 0 And y1 < #SPECHEIGHT)
            ind=y1 * #SPECWIDTH + x * 2 - 1
            specbuf(ind) = RGB(255-y1, y1+1, 0)
            y1 = y1 + 1
          Wend
        EndIf
        y1 = y
        y = y + 1
        While (y >= 0 And y < #SPECHEIGHT)
          ind=y * #SPECWIDTH + x * 2
          specbuf(ind) = RGB(255-y, y+1, 0)
          y = y + 1
        Wend
      Next x
    Case 1
      Define b0.l, BANDS.i
      b0 = 0
      BANDS = 21
      Define sc.l, b1.l, sum.f
      For x = 0 To BANDS
        sum = 0
        b1 = Pow(2, x * 10.0 / BANDS )
        If (b1 > 1023) : b1 = 1023 : EndIf
        If (b1 <= b0) : b1 = b0 + 1 : EndIf
        sc = 10 + b1 - b0
        Repeat
          sum = sum + fft(1 + b0)
          b0 = b0 + 1
        Until b0 >= b1
        y = #SPECHEIGHT - ((Sqr(sum / Log10(sc)) * 1.7 * #SPECHEIGHT) - 4)
        If y > #SPECHEIGHT : y = #SPECHEIGHT : EndIf
        y = y + 1
        While (y < #SPECHEIGHT And y >= 0)
          For w = 0 To 10
            specbuf((y * #SPECWIDTH + x * Int(#SPECWIDTH / BANDS))+w) = RGB(255-y, y+1, 0)
          Next
          y = y + 1
        Wend
      Next x
    Case 2
      Dim buf.f(0)
      Define c.l, ci.BASS_CHANNELINFO
     
      BASS_ChannelGetInfo(Handle, @ci)
      Dim buf(ci\chans * #SPECWIDTH * 4)
     
      BASS_ChannelGetData(Handle, @buf(0), (ci\chans * #SPECWIDTH * 4) | #BASS_DATA_FLOAT)
      For c = 0 To ci\chans - 1
        For x = 0 To #SPECWIDTH - 1
          v = (1 - buf(x * ci\chans + c)) * #SPECHEIGHT / 2
          If (v < 0)
            v = 0
          ElseIf (v >= #SPECHEIGHT)
            v = #SPECHEIGHT - 1
          EndIf
          If (x = 0) : y = v : EndIf
          Repeat
            If (y < v)
              y = y + 1
            ElseIf (y > v)
              y = y - 1
            EndIf
            specbuf(y * #SPECWIDTH + x) = IIF(Bool(c And 1), $FF0000, $0000FF)
          Until (y = v)
        Next x
      Next c
  EndSelect
  p = 0
  For u = 0 To #SPECHEIGHT-1
    For k = 0 To #SPECWIDTH-1
      If specbuf(p) <> 0
        Plot(k, u, specbuf(p))
      EndIf 
      p + 1
    Next
  Next
  StopDrawing()
EndProcedure

Procedure Loadfile()
  FileName = OpenFileRequester("","","*.*|*.*",0)
  If FileName
    Handle=BASS_StreamCreateFile(0, @FileName, 0, 0, #UNICODE)
    BASS_SetVolume(100)
    BASS_ChannelPlay(Handle,0)
    active = #True
  EndIf
EndProcedure

Procedure RenderSoundInfo()
  Protected fPos, aktSec.d, aktMin.d = 0, eTime.d, aktTime.s, endTime.s, tbPos.d
  Protected InfoString.s
  If Handle And active
    fPos = BASS_ChannelGetPosition(Handle, #BASS_POS_BYTE)
    ePos = BASS_ChannelGetLength(Handle, #BASS_POS_BYTE)
    aktSec = BASS_ChannelBytes2Seconds(Handle, fPos)
    eTime = BASS_ChannelBytes2Seconds(Handle, ePos)
    aktMin = Int(aktSec / 60)
    aktSec = Int(Mod(aktSec, 60))
    If aktSec < 10
      aktTime = StrD(aktMin) + ":" + "0" + StrD(aktSec)
    Else
      aktTime = StrD(aktMin) + ":" + StrD(aktSec)
    EndIf
    If Int(Mod(eTime, 60)) < 10
      endTime = StrD(Int(eTime / 60)) + ":" + "0" + StrD(Int(Mod(eTime, 60)))
    Else
      endTime = StrD(Int(eTime / 60)) + ":" + StrD(Int(Mod(eTime, 60)))
    EndIf
    InfoString = "File: " + GetFilePart(FileName)
    StartDrawing(CanvasOutput(info))
    DrawingMode(#PB_2DDrawing_Transparent)
    Box(0, 0, GadgetWidth(info), GadgetHeight(info), RGB(100,100,100))
    If TextWidth(InfoString) >= GadgetWidth(info)
      InfoString = Left(InfoString, 50) + "..."
    EndIf
    DrawText(0, 0, InfoString)
    DrawText(0, TextHeight("File: " + GetFilePart(FileName))*2, "Position: "  + aktTime + " Min / " + endTime + " Min")
    StopDrawing()
    If fPos > 0
      tbPos = 100 / ePos * fPos
      SetGadgetState(tracki, tbPos)
    EndIf
  EndIf
EndProcedure

#T_Update = 1

;- START
If OpenWindow(0,50,50,#SPECWIDTH,#SPECHEIGHT+140,"BASS Spectrum example")
 
  ButtonGadget(#BG_Load,50,#SPECHEIGHT+5,50,25,"Load")
  ButtonGadget(#BG_Stop,100,#SPECHEIGHT+5,50,25,"Stop")
  ButtonGadget(#BG_Play,150,#SPECHEIGHT+5,50,25,"Play")
  ButtonGadget(#BG_Pause,200,#SPECHEIGHT+5,50,25,"Pause")
  ButtonGadget(#BG_Next,250,#SPECHEIGHT+5,50,25,"Spectrum")
 
  cav = CanvasGadget(#PB_Any, 0, 0, #SPECWIDTH, #SPECHEIGHT)
 
  tracki = TrackBarGadget(#PB_Any, 10, #SPECHEIGHT + 50, #SPECWIDTH - 20, 10, 0, 100)
  info = CanvasGadget(#PB_Any, 10, #SPECHEIGHT + 75, #SPECWIDTH - 20, 60, #PB_Canvas_Border)
  SetGadgetColor(info, #PB_Gadget_BackColor, RGB(128,128,128))
 
  AddWindowTimer(#MainWin, #T_Update, 25)
  BASS_Init(-1, 44100, 0, WindowID(#MainWin), #Null)
 
  Loadfile()
 
  Repeat
    Event=WaitWindowEvent(10)
    Select Event
      Case #PB_Event_Gadget
        Select EventGadget()
          Case #BG_Load
            BASS_StreamFree(Handle)
            Loadfile()
          Case #BG_Play
            BASS_ChannelPlay(Handle,0)
          Case #BG_Pause
            BASS_ChannelPause(Handle)
          Case #BG_Stop
            BASS_ChannelStop(Handle)
            BASS_ChannelSetPosition(Handle,0,#BASS_POS_ByTE)
          Case #BG_Next
            specmode=(specmode+1)%3
          Case tracki
            If Handle And active
              active = #False
              epos = BASS_ChannelGetLength(Handle, #BASS_POS_BYTE)
              If epos > 0
                tbp = epos / 100 * GetGadgetState(tracki)
              EndIf
              BASS_ChannelPause(Handle)
              BASS_ChannelSetPosition(Handle, tbp, #BASS_POS_BYTE)
              BASS_ChannelPlay(Handle,0)
              active = #True
            EndIf
        EndSelect
      Case #PB_Event_Timer
        Select EventTimer()
          Case #T_Update
            UpdateSpectrum()
            RenderSoundInfo()
        EndSelect
    EndSelect
  Until Event=#PB_Event_CloseWindow
EndIf

BASS_Free()
End


Nach oben
 Profil  
Mit Zitat antworten  
Beiträge der letzten Zeit anzeigen:  Sortiere nach  
Ein neues Thema erstellen Auf das Thema antworten  [ 19 Beiträge ]  Gehe zu Seite Vorherige  1, 2

Alle Zeiten sind UTC + 1 Stunde [ Sommerzeit ]


Wer ist online?

Mitglieder in diesem Forum: 0 Mitglieder und 1 Gast


Sie dürfen keine neuen Themen in diesem Forum erstellen.
Sie dürfen keine Antworten zu Themen in diesem Forum erstellen.
Sie dürfen Ihre Beiträge in diesem Forum nicht ändern.
Sie dürfen Ihre Beiträge in diesem Forum nicht löschen.

Suche nach:
Gehe zu:  

 


Powered by phpBB © 2008 phpBB Group | Deutsche Übersetzung durch phpBB.de
subSilver+ theme by Canver Software, sponsor Sanal Modifiye