extends Node

"""
	100% pure GDScript software Mod Player [Godot Mod Player]
		by あるる（きのもと 結衣） @arlez80

	MIT License
"""

class_name ModPlayer, "icon.png"

# -------------------------------------------------------
# 定数
const mod_master_bus_name:String = "arlez80_GModP_MASTER_BUS"
const mod_channel_bus_name:String = "arlez80_GModP_CHANNEL_BUS%d"
const default_mix_rate:int = 4144
const default_linear_mix_rate:int = 8363
const chip_speed:float = 50.0
const volume_table:PoolRealArray = PoolRealArray([
	-144.0,-36.1,-30.1,-26.6,-24.1,-22.1,-20.6,-19.2,-18.1,-17,-16.1,-15.3,-14.5,-13.8,-13.2,-12.6,-12,-11.5,-11,-10.5,-10.1,-9.7,-9.3,-8.9,-8.5,-8.2,-7.8,-7.5,-7.2,-6.9,-6.6,-6.3,-6,-5.8,-5.5,-5.2,-5,-4.8,-4.5,-4.3,-4.1,-3.9,-3.7,-3.5,-3.3,-3.1,-2.9,-2.7,-2.5,-2.3,-2.1,-2,-1.8,-1.6,-1.5,-1.3,-1.2,-1,-0.9,-0.7,-0.6,-0.4,-0.3,-0.1,0.0
])

# -----------------------------------------------------------------------------
# Signals

signal note_on( channel_number, note )
signal looped

# -----------------------------------------------------------------------------
# Classes
class GodotModPlayerChannelAudioEffect:
	var ae_panner:AudioEffectPanner = null

class GodotModPlayerInstrument:
	var source:Object		# Mod.ModInstrument
	var array_ass:Array		# AudioStreamSample[]

class GodotModPlayerPitch:
	const center_key_freq:float = 856.0

	var value:int	# 現在値
	var dest:int	# 変化目標（ポルタメント用）
	var speed:int	# 変化量（ポルタメント用）

	var arpeggio:Array		# アルペジオリスト
	var arpeggio_count:int	# アルペジオカウンタ
	var arpeggio_enabled:bool

	var linear_freq:bool = false

	func _init( ):
		self.value = 0
		self.dest = 0
		self.speed = 0
		self.arpeggio = [0,0,0]
		self.arpeggio_count = 0
		self.arpeggio_enabled = false

	func update( ):
		if self.dest < self.value:
			self.value -= self.speed
			if self.value < self.dest:
				self.value = self.dest
				self.speed = 0
		elif self.value < self.dest:
			self.value += self.speed
			if self.dest < self.value:
				self.value = self.dest
				self.speed = 0

	"""
		現在のピッチスケールを得る

		@param	with	加算値
		@return	計算したピッチスケール
	"""
	func get_pitch_scale( with:int = 0 ) -> float:
		var v:int = self.value + with

		if self.arpeggio_enabled:
			v += self.arpeggio[self.arpeggio_count]
			self.arpeggio_count = ( self.arpeggio_count + 1 ) % 3

		if self.linear_freq:
			return pow( 2.0, ( 4608 - v ) / 768.0 )

		if v == 0:
			return 0.0001

		return center_key_freq / v

	"""
		ファインピッチスケールを取得

		@return	現在のファインピッチスケール
	"""
	func get_fine_pitch_scale( ) -> float:
		return pow( 2.0, ( self.value / 128.0 ) / 12.0 )

class GodotModPlayerEffect:
	var type:int = 0
	var phase:int = 0
	var speed:int = 0
	var depth:int = 0
	var depth_shift:int = 0

	var value:int = 0

	"""
		更新
	"""
	func update( ) -> void:
		var v:int = 0
		match self.type:
			Mod.ModWaveFormType.SINE_WAVEFORM:		# 正弦波
				# TODO: そのうちPoolByteArrayのtableにでもしておく
				v = int( sin( self.phase * ( PI / 32.0 ) ) * 255.0 )
			Mod.ModWaveFormType.SAW_WAVEFORM:		# のこぎり
				v = 255 - ( ( self.phase + 0x20 ) & 0x3F ) * 8
			Mod.ModWaveFormType.SQUARE_WAVEFORM:	# 矩形波
				v = 255 - ( self.phase & 0x20 ) * 16
			Mod.ModWaveFormType.RAMDOM_WAVEFORM:	# 乱数
				v = self.rng.randi( 511 ) - 255
			Mod.ModWaveFormType.REV_SAW_WAVEFORM:	# 逆のこぎり
				v = ( ( self.phase + 0x20 ) & 0x3F ) * 8

		self.phase += self.speed

		self.value = ( v * self.depth ) >> self.depth_shift

class GodotModPlayerEnvelope:
	const Mod = preload( "Mod.gd" )

	var source:Mod.ModEnvelope

	var frame:int = 0
	var value:int = 0
	var init_value:int = 0
	var sustain:bool = false
	var enabled:bool = false

	"""
		ノートオン

		@param	_source	エンベロープデータ
	"""
	func note_on( _source:Mod.ModEnvelope ) -> void:
		self.source = _source
		self.sustain = true
		self.frame = 0
		if self.source != null and self.source.enabled:
			self.value = self.source.points[0].value
		else:
			self.value = self.init_value

	"""
		ノートオフ
	"""
	func note_off( ) -> void:
		self.sustain = false

	"""
		更新
	"""
	func update( ) -> void:
		if self.source == null:
			self.value = self.init_value
			return

		self.enabled = self.source.enabled

		if not self.enabled:
			self.value = self.init_value
			return

		var current_point:int = 0
		var prev_sum_frame:int = 0
		var sum_frame:int = 0
		var loop_start_frame:int = 0
		for i in range( 1, self.source.point_count ):
			sum_frame += self.source.points[i].frame
			if self.source.loop_start_point == i:
				loop_start_frame = sum_frame
			if self.frame < sum_frame:
				var t:float = float( self.frame - prev_sum_frame ) / float( sum_frame - prev_sum_frame )
				var s:float = 1.0 - t
				self.value = int( self.source.points[i-1].value * s + self.source.points[i].value * t )
				break
			prev_sum_frame = sum_frame
			current_point = i

		if self.source.sustain_enabled and self.sustain and self.source.sustain_point == current_point:
			pass
		elif self.source.loop_enabled and self.source.loop_end_point == current_point:
			self.frame = loop_start_frame
		elif current_point == self.source.point_count and sum_frame < self.frame:
			self.frame = sum_frame
		else:
			self.frame += 1

class GodotModPlayerChannelStatus:
	const head_silent_second:float = 1.0
	const gap_second:float = 44100.0 / 1024.0 / 1000.0

	var source_inst:Object		# Mod.ModInstrument
	var source_sample:Object	# Mod.ModSample
	var asps:Array				# AudioStreamPlayer[]
	var asp_switcher:int

	var channel_number:int
	var last_instrument:int = -1
	var last_key_number:int = -1
	var mute:bool
	var pitch:GodotModPlayerPitch
	var fine_pitch:GodotModPlayerPitch
	var relative_pitch:float = 1.0

	var sample_number:int
	var volume:int
	var panning:int
	var amplified:int
	var fx_count:int
	var vibrato:GodotModPlayerEffect
	var tremolo:GodotModPlayerEffect

	var volume_env:GodotModPlayerEnvelope
	var panning_env:GodotModPlayerEnvelope

	var force_note_off:bool = false

	"""
		コンストラクタ

		@param	_channel_number	チャンネル番号
		@param	linear_freq		周波数指定が線形か？
	"""
	func _init( _channel_number:int, linear_freq:bool ):
		self.mute = false
		self.force_note_off = false

		self.channel_number = _channel_number
		self.panning = 128

		for i in range( 2 ):
			var asp: = AudioStreamPlayer.new( )
			asp.bus = mod_channel_bus_name % self.channel_number
			self.asps.append( asp )
		self.asp_switcher = 0

		self.pitch = GodotModPlayerPitch.new( )
		self.fine_pitch = GodotModPlayerPitch.new( )
		self.pitch.linear_freq = linear_freq
		self.fine_pitch.linear_freq = linear_freq
		self.vibrato = GodotModPlayerEffect.new( )
		self.vibrato.depth_shift = 7
		self.tremolo = GodotModPlayerEffect.new( )
		self.tremolo.depth_shift = 6
		self.volume_env = GodotModPlayerEnvelope.new( )
		self.volume_env.init_value = 64
		self.panning_env = GodotModPlayerEnvelope.new( )
		self.panning_env.init_value = 32

	"""
		Tick更新
	"""
	func tick_update( ) -> void:
		self.volume_env.update( )
		self.panning_env.update( )

	"""
		更新
	"""
	func update( ) -> void:
		if self.mute:
			for asp in self.asps:
				if asp.is_playing( ):
					asp.stop( )
			return

		for i in range( self.asps.size( ) ):
			var asp:AudioStreamPlayer = self.asps[i]
			if self.asp_switcher == i and ( not self.force_note_off ):
				if asp.is_playing( ):
					asp.volume_db = self.get_volume_db( )
					asp.pitch_scale = self.get_pitch_scale( )
			else:
				if asp.is_playing( ):
					asp.volume_db -= 4.0
					if asp.volume_db < -100.0:
						asp.stop( )

	"""
		volume_dbを取得

		@return	現在のvolume_dbを返す
	"""
	func get_volume_db( ) -> float:
		var v:float = ( clamp( self.volume + self.tremolo.value, 0.0, 64.0 ) / 64.0 ) * ( self.volume_env.value / 64.0 )
		return volume_table[int(v * 64)]

	"""
		ピッチスケールを取得

		@return	現在のピッチスケールを返す
	"""
	func get_pitch_scale( ) -> float:
		return self.pitch.get_pitch_scale( self.vibrato.value ) * self.relative_pitch * self.fine_pitch.get_fine_pitch_scale( )

	"""
		ノートオフ
	"""
	func note_off( ) -> void:
		self.volume_env.note_off( )
		self.panning_env.note_off( )

	"""
		ノートオン

		@param	inst			楽器データ
		@param	sample_number	サンプル番号
		@param	effect_command	エフェクトコマンド
		@param	key_number		周波数
		@param	note			ノート番号
	"""
	func note_on( inst:GodotModPlayerInstrument, sample_number:int, effect_command:int, key_number:int, note:int ) -> void:
		self.last_key_number = key_number

		if self.mute:
			return

		self.force_note_off = false
		self.asp_switcher = ( self.asp_switcher + 1 ) % self.asps.size( )

		self.source_inst = inst.source
		self.source_sample = self.source_inst.samples[note-1]
		if self.source_sample.panning != -1:
			self.panning = self.source_sample.panning

		var asp:AudioStreamPlayer = self.asps[self.asp_switcher]
		asp.stop( )
		asp.stream = inst.array_ass[note-1]
		self.volume = self.source_sample.volume
		self.sample_number = sample_number
		if effect_command == 0x03 || effect_command == 0x05:
			self.pitch.dest = key_number
		else:
			self.pitch.value = key_number
		self.fine_pitch.value = self.source_sample.finetune
		self.relative_pitch = pow( 2.0, self.source_sample.relative_note / 12.0 )
		if self.source_inst.vibrato_type != -1:
			self.vibrato.type = self.source_inst.vibrato_type
			self.vibrato.speed = self.source_inst.vibrato_speed
			self.vibrato.depth = self.source_inst.vibrato_depth
			self.vibrato.depth_shift = self.source_inst.vibrato_depth_shift

		self.volume_env.note_on( self.source_inst.volume_envelope )
		self.panning_env.note_on( self.source_inst.panning_envelope )

		asp.volume_db = self.get_volume_db( )
		var pitch_scale:float = self.get_pitch_scale( )
		asp.pitch_scale = pitch_scale
		asp.play( max( 0.0, self.head_silent_second - clamp( self.gap_second - AudioServer.get_time_to_next_mix( ), 0.0, self.gap_second ) * pitch_scale ) )

# -----------------------------------------------------------------------------
# Export

# ファイル
export (String, FILE, "*.mod,*.xm") var file:String = "" setget set_file
# 再生中か？
export (bool) var playing:bool = false
# 音量
export (float, -144.0, 0.0) var volume_db:float = -20.0 setget set_volume_db
# キーシフト（未実装）
#export (int) var key_shift:int = 0
# ループフラグ
export (bool) var loop:bool = false
# mix_target same as AudioStreamPlayer's one
export (int, "MIX_TARGET_STEREO", "MIX_TARGET_SURROUND", "MIX_TARGET_CENTER") var mix_target:int = AudioStreamPlayer.MIX_TARGET_STEREO
# bus same as AudioStreamPlayer's one
export (String) var bus:String = "Master"
# リリースタイムの発音軽減を与えてブツ切り回避する
#export (bool) var append_release_time:bool = true
# 1秒間処理する回数
export (int, 60, 480) var sequence_per_seconds:int = 120
# スレッドでの動作にするか
export (bool) var no_thread_mode:bool = false

# -----------------------------------------------------------------------------
# 変数

# Mod Playerスレッド
var thread:Thread = null
var mutex:Mutex = Mutex.new()
var thread_delete:bool = false
# Modデータ
var mod_data:Mod.ModData = null setget set_mod_data
# テンポ
var tempo:float = 125.0 setget set_tempo
# 行毎秒
var row_per_second:float = 0.02
# tick毎行
var tick_per_row:int = 4
# tick毎秒
var tick_per_second:float = 1.0 / chip_speed
# 次の行への秒数
var next_row_remain_second:float = 0.0
# 次のtickへの秒数
var next_tick_remain_second:float = 0.0
# 追加tick
var extra_tick:int = 0
# tick処理済み回数
var processed_tick_count:int = 0
# 位置（秒）
var position:float = 0.0
# 曲位置
var song_position:int = 0
# パターン内位置
var pattern_position:int = 0
# 次の行
var pattern_position_on_next_row:int = 0
# 楽器
var instruments:Array = []
# チャンネル
var channel_status:Array = []
# Modチャンネルエフェクト
var channel_audio_effects:Array = []
# パターンジャンプ先
var pattern_position_jump_point:int = 0
# パターンループカウンタ
var pattern_loop_count:int = 0
# パターンループ先
var pattern_loop_origin:int = 0
# 乱数
var rng:RandomNumberGenerator
# グローバル音量コマンドを有効にするか？
var enable_global_volume_command:bool = true
# グローバル音量 (mod/xm指定の数字)
var global_volume:int = 64
# グローバル音量 (計算用db)
var global_volume_db:float = 0.0

"""
	準備
"""
func _ready( ):
	# HTML5 もしくは デバッグモード時には強制的にスレッド未使用モードに変更する
	if OS.get_name( ) == "HTML5" or OS.is_debug_build( ):
		self.no_thread_mode = true

	self.rng = RandomNumberGenerator.new( )

	if AudioServer.get_bus_index( self.mod_master_bus_name ) == -1:
		AudioServer.add_bus( -1 )
		var mod_master_bus_idx:int = AudioServer.get_bus_count( ) - 1
		AudioServer.set_bus_name( mod_master_bus_idx, self.mod_master_bus_name )
		AudioServer.set_bus_send( mod_master_bus_idx, self.bus )
		AudioServer.set_bus_volume_db( AudioServer.get_bus_index( self.mod_master_bus_name ), self.volume_db )

		for i in range( 32 ):
			AudioServer.add_bus( -1 )
			var mod_channel_bus_idx:int = AudioServer.get_bus_count( ) - 1
			AudioServer.set_bus_name( mod_channel_bus_idx, self.mod_channel_bus_name % i )
			AudioServer.set_bus_send( mod_channel_bus_idx, self.mod_master_bus_name )
			AudioServer.set_bus_volume_db( mod_channel_bus_idx, 0.0 )

			var cae: = GodotModPlayerChannelAudioEffect.new( )
			cae.ae_panner = AudioEffectPanner.new( )
			AudioServer.add_bus_effect( mod_channel_bus_idx, cae.ae_panner )
			self.channel_audio_effects.append( cae )

	if self.playing:
		self.play( )

"""
	通知

	@param	what	通知要因
"""
func _notification( what:int ):
	# 破棄時
	if what == NOTIFICATION_PREDELETE:
		self.thread_delete = true
		if self.thread != null:
			self.thread.wait_to_finish( )
			self.thread = null
		#AudioServer.remove_bus( AudioServer.get_bus_index( self.mod_master_bus_name ) )
		#for i in range( 0, 16 ):
		#	AudioServer.remove_bus( AudioServer.get_bus_index( self.midi_channel_bus_name % i ) )

"""
	Mutex Lock (for debug purpose)
"""
func _lock( callee:String ) -> void:
	# print( "locked by %s" % callee )
	self.mutex.lock( )

"""
	Mutex Unload (for debug purpose)
"""
func _unlock( callee:String ) -> void:
	# print( "unlocked by %s" % callee )
	self.mutex.unlock( )

"""
	再生前の初期化
"""
func _prepare_to_play( ) -> void:
	self._lock( "prepare_to_play" )

	# ファイル読み込み
	if self.mod_data == null:
		match self.file.get_extension( ):
			"mod":
				var mod_reader: = Mod.new( )
				self.mod_data = mod_reader.read_file( self.file ).data
			"xm":
				var xm_reader: = XM.new( )
				var m:Object = xm_reader.read_file( self.file ).data
				self.mod_data = m
			_:
				self.mod_data = null

	if self.mod_data == null:
		self._unlock( "prepare_to_play" )
		self.stop( )
		return

	if self.channel_status != null:
		for t in self.channel_status:
			for asp in t.asps:
				self.remove_child( asp )

	self.set_volume_db( self.volume_db )

	self.instruments = []
	var temp_head_silent:Array = []
	var head_silent_samples:int = default_mix_rate
	if self.mod_data.flags & Mod.ModFlags.LINEAR_FREQUENCY_TABLE != 0:
		head_silent_samples = default_linear_mix_rate
	for i in range( head_silent_samples ):
		temp_head_silent.append( 0 )
	var head_silent:PoolByteArray = PoolByteArray( temp_head_silent )
	var loaded:Dictionary = {}
	for t in self.mod_data.instruments:
		var inst:GodotModPlayerInstrument = GodotModPlayerInstrument.new( )

		inst.source = t
		inst.array_ass = []

		for sample in t.samples:
			var id:int = sample.get_instance_id( )
			var ass:AudioStreamSample = null
			if not( id in loaded ):
				ass = AudioStreamSample.new( )
				ass.stereo = false
				if self.mod_data.flags & Mod.ModFlags.LINEAR_FREQUENCY_TABLE != 0:
					ass.mix_rate = self.default_linear_mix_rate
				else:
					ass.mix_rate = self.default_mix_rate
				if sample.bit == 16:
					ass.data = head_silent + head_silent  + sample.data
					ass.format = AudioStreamSample.FORMAT_16_BITS
				else:
					ass.data = head_silent + sample.data
					ass.format = AudioStreamSample.FORMAT_8_BITS
				ass.loop_begin = sample.loop_start + head_silent_samples
				ass.loop_end = ass.loop_begin + sample.loop_length
				if sample.bit == 16:
					ass.loop_begin /= 2
					ass.loop_end /= 2
				ass.loop_mode = AudioStreamSample.LOOP_DISABLED
				if sample.loop_type & Mod.ModLoopType.FORWARD_LOOP != 0:
					ass.loop_mode = AudioStreamSample.LOOP_FORWARD
				elif sample.loop_type & Mod.ModLoopType.PING_PONG_LOOP != 0:
					ass.loop_mode = AudioStreamSample.LOOP_PING_PONG
				loaded[id] = ass
				loaded[id] = ass
			else:
				ass = loaded[id]
			inst.array_ass.append( ass )

		self.instruments.append( inst )
	for k in loaded.keys( ):
		loaded.erase( k )

	self.channel_status = []
	for i in range( self.mod_data.channel_count ):
		var cs: = GodotModPlayerChannelStatus.new( i, self.mod_data.flags & Mod.ModFlags.LINEAR_FREQUENCY_TABLE != 0 )
		if 4 < self.mod_data.channel_count:
			cs.panning = 128
		else:
			cs.panning = [64,192,192,64][i]
		for asp in cs.asps:
			self.add_child( asp )
		self.channel_status.append( cs )

	self._unlock( "prepare_to_play" )

"""
	再生

	@param	from_position	再生開始位置（現在未実装）
"""
func play( from_position:float = 0.0 ):
	self._prepare_to_play( )
	if self.mod_data == null:
		return

	self.playing = true
	if from_position == 0.0:
		self.position = 0.0
		self.song_position = 0
		self.pattern_position_jump_point = 1
		self.pattern_position = -1
		self.pattern_position_on_next_row = -1
		self.pattern_loop_count = 0
		self.pattern_loop_origin = 0
		self.tick_per_second = 1.0 / self.chip_speed
		self.set_tempo( self.mod_data.init_bpm )
		self.set_tick( self.mod_data.init_tick )
		self.processed_tick_count = 10000
		self.next_tick_remain_second = 0.0
		self.next_row_remain_second = self.row_per_second
	else:
		self.seek( from_position )

"""
	シーク
	TODO:未実装

	@param	to_position	再生位置
"""
func seek( to_position:float ) -> void:
	self._lock( "seek" )
	self._previous_time = 0.0
	self._stop_all_notes( )
	self._unlock( "seek" )

"""
	停止
"""
func stop( ) -> void:
	self._lock( "stop" )
	self._stop_all_notes( )
	self.playing = false
	self._unlock( "stop" )

"""
	ファイル変更

	@param	path	ファイルパス
"""
func set_file( path:String ) -> void:
	file = path
	self.mod_data = null
	if self.playing:
		self.play( )

"""
	Modデータ変更

	@param	md	Modデータ
"""
func set_mod_data( md:Mod.ModData ) -> void:
	mod_data = md

"""
	音量設定

	@param	vdb	音量
"""
func set_volume_db( vdb:float ) -> void:
	var master_bus_id:int = AudioServer.get_bus_index( self.mod_master_bus_name )
	volume_db = vdb
	if master_bus_id == -1:
		return

	var gvdb:float = self.global_volume_db if self.enable_global_volume_command else 0.0
	AudioServer.set_bus_volume_db( master_bus_id, volume_db + gvdb )

"""
	全音を止める
"""
func _stop_all_notes( ) -> void:
	for t in self.channel_status:
		t.note_off( )
		t.force_note_off = true
		for asp in t.asps:
			if asp.is_playing( ):
				asp.stop( )

"""
	テンポ設定

	@param	_tempo	テンポ
"""
func set_tempo( _tempo:float ) -> void:
	tempo = _tempo
	self.tick_per_second = 1.0 / ( self.chip_speed * ( _tempo / 125.0 ) )
	self.next_row_remain_second -= self.row_per_second
	self.row_per_second = self.tick_per_row * self.tick_per_second
	self.next_row_remain_second += self.row_per_second

"""
	tickからテンポ設定

	@param	_tick	Tick数
"""
func set_tick( _tick:int ) -> void:
	self.tick_per_row = _tick
	self.next_row_remain_second -= self.row_per_second
	self.row_per_second = self.tick_per_row * self.tick_per_second
	self.next_row_remain_second += self.row_per_second

"""
	1フレームでの処理

	@param	delta	
"""
func _process( delta:float ):
	if self.no_thread_mode:
		self._sequence( delta )
	else:
		if self.thread == null or ( not self.thread.is_alive( ) ):
			self._lock( "_process" )
			if self.thread != null:
				self.thread.wait_to_finish( )
			self.thread = Thread.new( )
			self.thread.start( self, "_thread_process" )
			self._unlock( "_process" )

"""
	スレッド処理
"""
func _thread_process( ) -> void:
	var last_time:int = OS.get_ticks_usec( )

	while not self.thread_delete:
		self._lock( "_thread_process" )

		var current_time:int = OS.get_ticks_usec( )
		var delta:float = ( current_time - last_time ) / 1000000.0
		self._sequence( delta )

		self._unlock( "_thread_process" )

		last_time = current_time
		var msec:int = int( 1000.0 / self.sequence_per_seconds )
		OS.delay_msec( msec )

"""
	シーケンス処理を行う

	@param	delta	前回からの経過時間 sec
"""
func _sequence( delta:float ) -> void:
	if delta < 0.0:
		return

	if self.mod_data != null:
		if self.playing:
			self.position += delta
			self.next_row_remain_second -= delta
			self.next_tick_remain_second -= delta
			if self.next_row_remain_second <= 0.0:
				self.next_tick_remain_second = -INF
			while self.next_tick_remain_second <= 0.0 and self.processed_tick_count < self.tick_per_row + self.extra_tick:
				self._process_tick( )
				self.next_tick_remain_second += self.tick_per_second
				self._process_row( )
				self.processed_tick_count += 1
			if self.next_row_remain_second <= 0.0:
				self.extra_tick = 0
				self._process_move_to_next_line( )
				self.next_row_remain_second = self.row_per_second + self.next_row_remain_second
				self.next_tick_remain_second = 0.0
				self.processed_tick_count = 1
			self._process_update_audio_effects( )

"""
	次の行に移行する
"""
func _process_move_to_next_line( ) -> void:
	if 0 <= self.pattern_position_on_next_row:
		self.pattern_position = self.pattern_position_on_next_row
		self.pattern_position_on_next_row = -1
		self.song_position = self.pattern_position_jump_point
		self.pattern_position_jump_point = self.song_position + 1
	else:
		self.pattern_position += 1
		if len( self.mod_data.patterns[self.mod_data.song_positions[self.song_position]] ) <= self.pattern_position:
			self.pattern_position = 0
			self.song_position = self.pattern_position_jump_point
			self.pattern_position_jump_point = self.song_position + 1

	if self.mod_data.song_length <= self.song_position:
		if self.loop:
			self.song_position = self.mod_data.restart_position
			self.pattern_position_jump_point = self.song_position + 1
			self.emit_signal( "looped" )
		else:
			self.song_position = 0
			self.stop( )
			return

"""
	1行処理
"""
func _process_row( ) -> void:
	var pattern_line:Array = self.mod_data.patterns[self.mod_data.song_positions[self.song_position]][self.pattern_position]
	for channel in self.channel_status:
		self._process_row_for_channel( channel, pattern_line[channel.channel_number] )

"""
	チャンネルごとの1行処理

	@param	channel	チャンネルデータ
	@param	note	ノートデータ
"""
func _process_row_for_channel( channel:GodotModPlayerChannelStatus, note:Mod.ModPatternNote ) -> void:
	#printt( channel.channel_number, pattern_node.sample_number, pattern_node.key_number, pattern_node.effect_command )

	var note_on:bool = self.processed_tick_count == 1
	# Note関係のエフェクトコマンド
	if note.effect_command == 0x0E:
		match ( note.effect_param >> 4 ):
			0x09:	# Retrigger Note
				note_on = ( ( self.processed_tick_count - 1 ) % ( note.effect_param & 0x0F ) ) == 0
			0x0D:	# Note Delay
				note_on = ( note.effect_param & 0x0F ) == self.processed_tick_count - 1

	# 楽器設定
	if note.instrument != 0:
		channel.last_instrument = note.instrument - 1
	# 発音
	if note_on:
		channel.pitch.arpeggio_count = 0
		if note.note == 96:
			channel.note_off( )
		elif 0 < note.key_number:
			if 0 <= channel.last_instrument and channel.last_instrument < self.instruments.size( ):
				var inst:GodotModPlayerInstrument = self.instruments[channel.last_instrument]
				channel.note_on( inst, note.instrument, note.effect_command, note.key_number, note.note )

			self.emit_signal( "note_on", channel.channel_number, note )
		elif note.instrument != 0:
			if 0 <= channel.last_instrument and channel.last_instrument < self.instruments.size( ) and 0 <= channel.last_key_number:
				var inst:GodotModPlayerInstrument = self.instruments[channel.last_instrument]
				channel.note_on( inst, note.instrument, note.effect_command, channel.last_key_number, note.note )

			self.emit_signal( "note_on", channel.channel_number, note )

	if self.processed_tick_count == 1:
		self._process_tick_for_channel( channel, note, true )

"""
	1tick処理
"""
func _process_tick( ) -> void:
	if self.pattern_position < 0:
		return

	var pattern_line:Array = self.mod_data.patterns[self.mod_data.song_positions[self.song_position]][self.pattern_position]
	for channel in self.channel_status:
		self._process_tick_for_channel( channel, pattern_line[channel.channel_number], false )

"""
	チャンネルごとの1tick処理

	@param	channel				チャンネルデータ
	@param	note				ノートデータ
	@param	disable_channel_row	チャンネルイベントを無視する
"""
func _process_tick_for_channel( channel:GodotModPlayerChannelStatus, note:Mod.ModPatternNote, disable_channel_row:bool ) -> void:
	#print( "%08x %08x" % [ note.effect_command, note.effect_param ] )

	channel.pitch.arpeggio_enabled = false
	channel.vibrato.value = 0
	channel.tremolo.value = 0

	channel.tick_update( )

	if 0x10 <= note.volume and note.volume <= 0x50:
		channel.volume = note.volume - 0x10
	elif 0x60 <= note.volume:
		match note.volume >> 4:
			0x06:	# Volume slide down
				if not disable_channel_row:
					channel.volume = int( clamp( channel.volume - ( note.volume & 0x0F ), 0, 64 ) )
			0x07:	# Volume slide up
				if not disable_channel_row:
					channel.volume = int( clamp( channel.volume + ( note.volume & 0x0F ), 0, 64 ) )
			0x08:	# Fine volume slide down
				if not disable_channel_row:
					channel.volume = int( clamp( channel.volume - ( note.volume & 0x0F ), 0, 64 ) )
			0x09:	# Fine volume slide up
				if not disable_channel_row:
					channel.volume = int( clamp( channel.volume + ( note.volume & 0x0F ), 0, 64 ) )
			0x0A:	# Set vibrato speed
				channel.vibrato.speed = (channel.vibrato.speed & 0x0F) | ( ( note.volume & 0x0F ) << 4 );
			0x0C:	# Panning
				var p:int = note.volume & 0x0F
				p |= p << 4
				channel.panning = p
			0x0D:	# Panning slide left
				if not disable_channel_row:
					channel.panning = int( clamp( channel.panning - ( note.panning & 0x0F ), 0, 255 ) )
			0x0E:	# Panning slide right
				if not disable_channel_row:
					channel.panning = int( clamp( channel.panning + ( note.panning & 0x0F ), 0, 255 ) )
			0x0F:	# Tone portamento
				if 0 < note.volume & 0x0F:
					var p:int = note.volume & 0x0F
					p |= p << 4
					channel.pitch.speed = p
			_:
				printerr( "unknown volume effect command: %02x" % note.volume )

	# エフェクトコマンド
	match note.effect_command:
		0x00:	# Arpeggio
			channel.pitch.arpeggio[1] = int( channel.pitch.value / pow( 2.0, ( note.effect_param >> 4 ) / 12.0 ) ) - channel.pitch.value
			channel.pitch.arpeggio[2] = int( channel.pitch.value / pow( 2.0, ( note.effect_param & 0x0F ) / 12.0 ) ) - channel.pitch.value
			channel.pitch.arpeggio_enabled = true
		0x01:	# Portament up
			if not disable_channel_row:
				channel.pitch.value = int( max( channel.pitch.value - note.effect_param, 0 ) )
		0x02:	# Portament down
			if not disable_channel_row:
				channel.pitch.value = channel.pitch.value + note.effect_param
		0x03:	# Portament speed
			channel.pitch.speed = note.effect_param
			channel.pitch.update( )
		0x04:	# Vibrato
			if 0 < note.effect_param & 0xF0:
				channel.vibrato.speed = note.effect_param >> 4
			if 0 < note.effect_param & 0x0F:
				channel.vibrato.depth = note.effect_param & 0x0F
			channel.vibrato.update( )
		0x05:	# Portament + Volume slide
			channel.pitch.update( )
			channel.volume = int( clamp( channel.volume + ( note.effect_param >> 4 ) - ( note.effect_param & 0x0F ), 0, 64 ) )
		0x06:	# Vibrato + Volume slide
			channel.vibrato.update( )
			channel.volume = int( clamp( channel.volume + ( note.effect_param >> 4 ) - ( note.effect_param & 0x0F ), 0, 64 ) )
		0x07:	# Tremolo
			if 0 < note.effect_param & 0xF0:
				channel.tremolo.speed = note.effect_param >> 4
			if 0 < note.effect_param & 0x0F:
				channel.tremolo.depth = note.effect_param & 0x0F
			channel.tremolo.update( )
		0x08:	# Panning
			channel.panning = int( clamp( note.effect_param * 2, 0, 255 ) )
		0x09:	# Sample offset
			printerr( "not implemented: 9xx Sample offset" )
		0x0A:	# Volume slide
			if not disable_channel_row:
				channel.volume = int( clamp( channel.volume + ( note.effect_param >> 4 ) - ( note.effect_param & 0x0F ), 0, 64 ) )
		0x0B:	# Pattern jump
			if disable_channel_row:
				self.pattern_position_jump_point = note.effect_param
				self.pattern_position_on_next_row = 0
		0x0C:	# Volume
			channel.volume = int( clamp( note.effect_param, 0, 64 ) )
		0x0D:	# Pattern break
			if disable_channel_row:
				self.pattern_position_jump_point = self.song_position + 1
				self.pattern_position_on_next_row = ( note.effect_param >> 4 ) * 10 + ( note.effect_param & 0x0F )
				if 64 <= self.pattern_position_on_next_row:
					self.pattern_position_on_next_row = 0
		0x0E:	# 拡張コマンド
			match ( note.effect_param >> 4 ):
				0x01:	# Fine portamento up
					if 0 < note.effect_param & 0x0F:
						channel.fine_pitch.speed = note.effect_param & 0x0F
					channel.fine_pitch.update( )
				0x02:	# Fine portamento down
					if 0 < note.effect_param & 0x0F:
						channel.fine_pitch.speed = - (note.effect_param & 0x0F)
					channel.fine_pitch.update( )
				0x04:	# Vibrato type
					channel.vibrato.type = note.effect_param
					channel.vibrato.update( )
				0x06:	# Pattern loop
					if disable_channel_row:
						if 0 < ( note.effect_param & 0x0F ):
							if ( note.effect_param & 0x0F ) == self.pattern_loop_count:
								self.pattern_loop_count = 0
							else:
								self.pattern_loop_count += 1
								self.pattern_position_jump_point = self.song_position
								self.pattern_position_on_next_row = self.pattern_loop_origin
						else:
							self.pattern_loop_origin = self.pattern_position
				0x07:	# Tremoro type
					channel.tremolo.type = note.effect_param
					channel.tremolo.update( )
				0x09:	# Retrigger Note
					pass
				0x0A:	# Fine volume slide up
					if not disable_channel_row:
						channel.volume = int( clamp( channel.volume + ( note.volume & 0x0F ), 0, 64 ) )
				0x0B:	# Fine volume slide down
					if not disable_channel_row:
						channel.volume = int( clamp( channel.volume - ( note.volume & 0x0F ), 0, 64 ) )
				0x0C:	# Note cut
					if self.processed_tick_count - 1 == note.effect_param & 0x0F:
						channel.volume = 0
				0x0D:	# Note delay （上で処理する）
					pass
				0x0E:	# Pattern delay
					var r:int = ( note.effect_param & 0x0F )
					self.extra_tick = r * self.tick_per_row
					if disable_channel_row:
						self.next_row_remain_second += self.row_per_second * r
				_:
					printerr( "unknown extended command: %04x" % [ note.effect_param ] )
		0x0F:	# Tick / Tempo
			if disable_channel_row:
				if note.effect_param < 0x20:
					self.set_tick( note.effect_param )
				else:
					self.set_tempo( note.effect_param )
		0x10:	# Global volume
			self.global_volume = int( clamp( note.effect_param, 0, 64 ) )
			self.global_volume_db = self.volume_table[self.global_volume]
			self.set_volume_db( self.volume_db )
		0x11:	# Global volume slide
			self.global_volume = int( clamp( self.global_volume + ( note.effect_param >> 4 ) - ( note.effect_param & 0x0F ), 0, 64 ) )
			self.global_volume_db = self.volume_table[self.global_volume]
			self.set_volume_db( self.volume_db )
		0x14:	# Key off
			printerr( "not implemented: Kxx Key off" )
		0x15:	# Set envelope position
			channel.tremolo.phase = note.effect_param
		0x19:	# Pannning slide
			if not disable_channel_row:
				channel.panning = int( clamp( channel.panning + ( note.effect_param >> 4 ) - ( note.effect_param & 0x0F ), 0, 255 ) )
		0x1B:	# Multi retrig note
			printerr( "not implemented: Rxy Multi retrig note" )
		0x1D:	# Tremor
			printerr( "not implemented: Txy Tremor" )
		_:
			printerr( "unknown command: %02x : %04x" % [ note.effect_command, note.effect_param ] )

"""
	Godotのオーディオエフェクト更新
"""
func _process_update_audio_effects( ) -> void:
	for channel in self.channel_status:
		channel.update( )
		var cae:GodotModPlayerChannelAudioEffect = self.channel_audio_effects[channel.channel_number]
		cae.ae_panner.pan = clamp( ( ( channel.panning - 128 ) / 128.0 ) + ( ( channel.panning_env.value - 32 ) / 32.0 ), -1.0, 1.0 )