Add source write methods

FangCunWuChang · FangCunWuChang · commit 8bdb80df1529 · 2024-11-30T00:49:07.000+08:00
diff --git a/src/audioCore/source/SourceInternalContainer.cpp b/src/audioCore/source/SourceInternalContainer.cpp
@@ -139,6 +139,36 @@ void SourceInternalContainer::setAudio(
 	}
 }
 
+void SourceInternalContainer::writeAudio(AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+	double startTime, double length, double sampleRate) {
+	if (this->type == SourceType::Audio) {
+		/** Init Audio */
+		if (!this->audioData) {
+			this->initAudioData(buffer.getNumChannels(), sampleRate, startTime + length);
+		}
+		
+		/** TODO Write Data */
+
+		/** Set Flag */
+		this->changed();
+	}
+}
+
+void SourceInternalContainer::writeMIDI(MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+	double startTime, double length) {
+	if (this->type == SourceType::MIDI) {
+		/** Init Audio */
+		if (!this->midiData) {
+			this->initMidiData();
+		}
+
+		/** TODO Write Data */
+
+		/** Set Flag */
+		this->changed();
+	}
+}
+
 void SourceInternalContainer::setAudioFormat(const AudioFormat& format) {
 	if (this->type == SourceType::Audio) {
 		std::tie(this->format, this->metaData, this->bitsPerSample, this->quality) = format;
diff --git a/src/audioCore/source/SourceInternalContainer.h b/src/audioCore/source/SourceInternalContainer.h
@@ -36,6 +36,13 @@ class SourceInternalContainer {
 	void setMIDI(const juce::MidiFile& data);
 	void setAudio(double sampleRate, const juce::AudioSampleBuffer& data);
 
+	enum class AudioWriteType { Insert, Cover };
+	enum class MIDIWriteType { NewTrack, Insert, Cover };
+	void writeAudio(AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+		double startTime, double length, double sampleRate);
+	void writeMIDI(MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+		double startTime, double length);
+
 	/** Format, MetaData, BitDepth, Quality */
 	using AudioFormat = std::tuple<juce::String, juce::StringPairArray, int, int>;
 	void setAudioFormat(const AudioFormat& format);
diff --git a/src/audioCore/source/SourceItem.cpp b/src/audioCore/source/SourceItem.cpp
@@ -162,6 +162,47 @@ const juce::MidiFile SourceItem::makeMIDIFile() const {
 	return this->container->makeMIDIFile();
 }
 
+void SourceItem::writeAudio(AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+	double startTime, double length, double sampleRate) {
+	/** Check Type */
+	if (this->type != SourceType::Audio) { return; }
+
+	/** Init or Fork */
+	if (this->container) {
+		this->forkIfNeed();
+	}
+	else {
+		this->initAudio(juce::String{},
+			buffer.getNumChannels(), sampleRate, startTime + length);
+	}
+
+	/** Write Data */
+	this->container->writeAudio(type, buffer, startTime, length, sampleRate);
+
+	/** Callback */
+	this->invokeCallback();
+}
+
+void SourceItem::writeMIDI(MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+	double startTime, double length) {
+	/** Check Type */
+	if (this->type != SourceType::MIDI) { return; }
+
+	/** Init or Fork */
+	if (this->container) {
+		this->forkIfNeed();
+	}
+	else {
+		this->initMIDI(juce::String{});
+	}
+
+	/** Write Data */
+	this->container->writeMIDI(type, sequence, startTime, length);
+
+	/** Callback */
+	this->invokeCallback();
+}
+
 void SourceItem::changed() {
 	if (!this->container) { return; }
 	this->container->changed();
diff --git a/src/audioCore/source/SourceItem.h b/src/audioCore/source/SourceItem.h
@@ -23,6 +23,13 @@ class SourceItem final {
 	const juce::MidiMessageSequence makeMIDITrack(int trackIndex) const;
 	const juce::MidiFile makeMIDIFile() const;
 
+	using AudioWriteType = SourceInternalContainer::AudioWriteType;
+	using MIDIWriteType = SourceInternalContainer::MIDIWriteType;
+	void writeAudio(AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+		double startTime, double length, double sampleRate);
+	void writeMIDI(MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+		double startTime, double length);
+
 	void changed();
 	void saved();
 	bool isSaved() const;
diff --git a/src/audioCore/source/SourceManager.cpp b/src/audioCore/source/SourceManager.cpp
@@ -177,6 +177,24 @@ const juce::MidiFile SourceManager::makeMIDIFile(uint64_t ref) const {
 	return {};
 }
 
+void SourceManager::writeAudio(uint64_t ref,
+	AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+	double startTime, double length, double sampleRate) {
+	juce::ScopedWriteLock locker(audioLock::getSourceLock());
+	if (auto ptr = this->getSource(ref, SourceType::Audio)) {
+		ptr->writeAudio(type, buffer, startTime, length, sampleRate);
+	}
+}
+
+void SourceManager::writeMIDI(uint64_t ref,
+	MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+	double startTime, double length) {
+	juce::ScopedWriteLock locker(audioLock::getSourceLock());
+	if (auto ptr = this->getSource(ref, SourceType::Audio)) {
+		ptr->writeMIDI(type, sequence, startTime, length);
+	}
+}
+
 void SourceManager::prepareAudioPlay(uint64_t ref) {
 	juce::ScopedWriteLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSource(ref, SourceType::Audio)) {
@@ -238,90 +256,103 @@ void SourceManager::readMIDIData(uint64_t ref, juce::MidiBuffer& buffer, double
 }
 
 int SourceManager::getMIDINoteNum(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDINoteNum(track);
 	}
 	return 0;
 }
 
 int SourceManager::getMIDIPitchWheelNum(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIPitchWheelNum(track);
 	}
 	return 0;
 }
 
 int SourceManager::getMIDIAfterTouchNum(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIAfterTouchNum(track);
 	}
 	return 0;
 }
 
 int SourceManager::getMIDIChannelPressureNum(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIChannelPressureNum(track);
 	}
 	return 0;
 }
 
 const std::set<uint8_t> SourceManager::getMIDIControllerNumbers(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIControllerNumbers(track);
 	}
 	return {};
 }
 
 int SourceManager::getMIDIControllerNum(uint64_t ref, int track, uint8_t number) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIControllerNum(track, number);
 	}
 	return 0;
 }
 
 int SourceManager::getMIDIMiscNum(uint64_t ref, int track) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIMiscNum(track);
 	}
 	return 0;
 }
 
 const SourceMIDITemp::Note SourceManager::getMIDINote(uint64_t ref, int track, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDINote(track, index);
 	}
 	return {};
 }
 
 const SourceMIDITemp::IntParam SourceManager::getMIDIPitchWheel(uint64_t ref, int track, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIPitchWheel(track, index);
 	}
 	return {};
 }
 
 const SourceMIDITemp::AfterTouch SourceManager::getMIDIAfterTouch(uint64_t ref, int track, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIAfterTouch(track, index);
 	}
 	return {};
 }
 
 const SourceMIDITemp::IntParam SourceManager::getMIDIChannelPressure(uint64_t ref, int track, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIChannelPressure(track, index);
 	}
 	return {};
 }
 
 const SourceMIDITemp::Controller SourceManager::getMIDIController(uint64_t ref, int track, uint8_t number, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIController(track, number, index);
 	}
 	return {};
 }
 
 const SourceMIDITemp::Misc SourceManager::getMIDIMisc(uint64_t ref, int track, int index) const {
+	juce::ScopedReadLock locker(audioLock::getSourceLock());
 	if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {
 		return ptr->getMIDIMisc(track, index);
 	}
diff --git a/src/audioCore/source/SourceManager.h b/src/audioCore/source/SourceManager.h
@@ -30,6 +30,13 @@ class SourceManager final : private juce::DeletedAtShutdown {
 	const juce::MidiMessageSequence makeMIDITrack(uint64_t ref, int trackIndex) const;
 	const juce::MidiFile makeMIDIFile(uint64_t ref) const;
 
+	using AudioWriteType = SourceItem::AudioWriteType;
+	using MIDIWriteType = SourceItem::MIDIWriteType;
+	void writeAudio(uint64_t ref, AudioWriteType type, const juce::AudioSampleBuffer& buffer,
+		double startTime, double length, double sampleRate);
+	void writeMIDI(uint64_t ref, MIDIWriteType type, const juce::MidiMessageSequence& sequence,
+		double startTime, double length);
+
 	void prepareAudioPlay(uint64_t ref);
 	void prepareMIDIPlay(uint64_t ref);
 

Original file line number	Diff line number	Diff line change
`@@ -177,6 +177,24 @@ const juce::MidiFile SourceManager::makeMIDIFile(uint64_t ref) const {`
`177`	`177`	`return {};`
`178`	`178`	`}`
`179`	`179`
	`180`	`+void SourceManager::writeAudio(uint64_t ref,`
	`181`	`+ AudioWriteType type, const juce::AudioSampleBuffer& buffer,`
	`182`	`+ double startTime, double length, double sampleRate) {`
	`183`	`+ juce::ScopedWriteLock locker(audioLock::getSourceLock());`
	`184`	`+ if (auto ptr = this->getSource(ref, SourceType::Audio)) {`
	`185`	`+ ptr->writeAudio(type, buffer, startTime, length, sampleRate);`
	`186`	`+ }`
	`187`	`+}`
	`188`	`+`
	`189`	`+void SourceManager::writeMIDI(uint64_t ref,`
	`190`	`+ MIDIWriteType type, const juce::MidiMessageSequence& sequence,`
	`191`	`+ double startTime, double length) {`
	`192`	`+ juce::ScopedWriteLock locker(audioLock::getSourceLock());`
	`193`	`+ if (auto ptr = this->getSource(ref, SourceType::Audio)) {`
	`194`	`+ ptr->writeMIDI(type, sequence, startTime, length);`
	`195`	`+ }`
	`196`	`+}`
	`197`	`+`
`180`	`198`	`void SourceManager::prepareAudioPlay(uint64_t ref) {`
`181`	`199`	`juce::ScopedWriteLock locker(audioLock::getSourceLock());`
`182`	`200`	`if (auto ptr = this->getSource(ref, SourceType::Audio)) {`
`@@ -238,90 +256,103 @@ void SourceManager::readMIDIData(uint64_t ref, juce::MidiBuffer& buffer, double`
`238`	`256`	`}`
`239`	`257`
`240`	`258`	`int SourceManager::getMIDINoteNum(uint64_t ref, int track) const {`
	`259`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`241`	`260`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`242`	`261`	`return ptr->getMIDINoteNum(track);`
`243`	`262`	`}`
`244`	`263`	`return 0;`
`245`	`264`	`}`
`246`	`265`
`247`	`266`	`int SourceManager::getMIDIPitchWheelNum(uint64_t ref, int track) const {`
	`267`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`248`	`268`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`249`	`269`	`return ptr->getMIDIPitchWheelNum(track);`
`250`	`270`	`}`
`251`	`271`	`return 0;`
`252`	`272`	`}`
`253`	`273`
`254`	`274`	`int SourceManager::getMIDIAfterTouchNum(uint64_t ref, int track) const {`
	`275`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`255`	`276`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`256`	`277`	`return ptr->getMIDIAfterTouchNum(track);`
`257`	`278`	`}`
`258`	`279`	`return 0;`
`259`	`280`	`}`
`260`	`281`
`261`	`282`	`int SourceManager::getMIDIChannelPressureNum(uint64_t ref, int track) const {`
	`283`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`262`	`284`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`263`	`285`	`return ptr->getMIDIChannelPressureNum(track);`
`264`	`286`	`}`
`265`	`287`	`return 0;`
`266`	`288`	`}`
`267`	`289`
`268`	`290`	`const std::set<uint8_t> SourceManager::getMIDIControllerNumbers(uint64_t ref, int track) const {`
	`291`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`269`	`292`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`270`	`293`	`return ptr->getMIDIControllerNumbers(track);`
`271`	`294`	`}`
`272`	`295`	`return {};`
`273`	`296`	`}`
`274`	`297`
`275`	`298`	`int SourceManager::getMIDIControllerNum(uint64_t ref, int track, uint8_t number) const {`
	`299`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`276`	`300`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`277`	`301`	`return ptr->getMIDIControllerNum(track, number);`
`278`	`302`	`}`
`279`	`303`	`return 0;`
`280`	`304`	`}`
`281`	`305`
`282`	`306`	`int SourceManager::getMIDIMiscNum(uint64_t ref, int track) const {`
	`307`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`283`	`308`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`284`	`309`	`return ptr->getMIDIMiscNum(track);`
`285`	`310`	`}`
`286`	`311`	`return 0;`
`287`	`312`	`}`
`288`	`313`
`289`	`314`	`const SourceMIDITemp::Note SourceManager::getMIDINote(uint64_t ref, int track, int index) const {`
	`315`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`290`	`316`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`291`	`317`	`return ptr->getMIDINote(track, index);`
`292`	`318`	`}`
`293`	`319`	`return {};`
`294`	`320`	`}`
`295`	`321`
`296`	`322`	`const SourceMIDITemp::IntParam SourceManager::getMIDIPitchWheel(uint64_t ref, int track, int index) const {`
	`323`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`297`	`324`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`298`	`325`	`return ptr->getMIDIPitchWheel(track, index);`
`299`	`326`	`}`
`300`	`327`	`return {};`
`301`	`328`	`}`
`302`	`329`
`303`	`330`	`const SourceMIDITemp::AfterTouch SourceManager::getMIDIAfterTouch(uint64_t ref, int track, int index) const {`
	`331`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`304`	`332`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`305`	`333`	`return ptr->getMIDIAfterTouch(track, index);`
`306`	`334`	`}`
`307`	`335`	`return {};`
`308`	`336`	`}`
`309`	`337`
`310`	`338`	`const SourceMIDITemp::IntParam SourceManager::getMIDIChannelPressure(uint64_t ref, int track, int index) const {`
	`339`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`311`	`340`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`312`	`341`	`return ptr->getMIDIChannelPressure(track, index);`
`313`	`342`	`}`
`314`	`343`	`return {};`
`315`	`344`	`}`
`316`	`345`
`317`	`346`	`const SourceMIDITemp::Controller SourceManager::getMIDIController(uint64_t ref, int track, uint8_t number, int index) const {`
	`347`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`318`	`348`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`319`	`349`	`return ptr->getMIDIController(track, number, index);`
`320`	`350`	`}`
`321`	`351`	`return {};`
`322`	`352`	`}`
`323`	`353`
`324`	`354`	`const SourceMIDITemp::Misc SourceManager::getMIDIMisc(uint64_t ref, int track, int index) const {`
	`355`	`+ juce::ScopedReadLock locker(audioLock::getSourceLock());`
`325`	`356`	`if (auto ptr = this->getSourceFast(ref, SourceType::MIDI)) {`
`326`	`357`	`return ptr->getMIDIMisc(track, index);`
`327`	`358`	`}`