Java Language
ऑडियो

टिप्पणियों

एक ऑडियो फ़ाइल लूपेड चलाएं

आवश्यक आयात:

import javax.sound.sampled.AudioSystem;
import javax.sound.sampled.Clip;

यह कोड एक क्लिप बनाएगा और इसे एक बार शुरू करने के बाद लगातार चलाएगा:

Clip clip = AudioSystem.getClip();
clip.open(AudioSystem.getAudioInputStream(new URL(filename)));
clip.start();
clip.loop(Clip.LOOP_CONTINUOUSLY);

सभी समर्थित फ़ाइल प्रकारों के साथ एक सरणी प्राप्त करें:

AudioFileFormat.Type [] audioFileTypes = AudioSystem.getAudioFileTypes();

एक मिडी फ़ाइल चलाएं

MIDI फाइलें javax.sound.midi पैकेज से कई वर्गों का उपयोग करके खेली जा सकती हैं। एक Sequencer MIDI फ़ाइल का प्लेबैक करता है, और इसके कई तरीकों का उपयोग प्लेबैक नियंत्रण जैसे कि लूप काउंट, टेम्पो, ट्रैक म्यूटिंग और अन्य को सेट करने के लिए किया जा सकता है।

मिडी डेटा का सामान्य प्लेबैक इस तरह से किया जा सकता है:

import java.io.File;
import java.io.IOException;
import javax.sound.midi.InvalidMidiDataException;
import javax.sound.midi.MidiSystem;
import javax.sound.midi.MidiUnavailableException;
import javax.sound.midi.Sequence;
import javax.sound.midi.Sequencer;

public class MidiPlayback {
    public static void main(String[] args) {
        try {
            Sequencer sequencer = MidiSystem.getSequencer(); // Get the default Sequencer
            if (sequencer==null) {
                System.err.println("Sequencer device not supported");
                return;
            } 
            sequencer.open(); // Open device
            // Create sequence, the File must contain MIDI file data.
            Sequence sequence = MidiSystem.getSequence(new File(args[0]));
            sequencer.setSequence(sequence); // load it into sequencer
            sequencer.start();  // start the playback
        } catch (MidiUnavailableException | InvalidMidiDataException | IOException ex) {
            ex.printStackTrace();
        }
    }
}

प्लेबैक उपयोग को रोकने के लिए:

sequencer.stop(); // Stop the playback

एक सीक्वेंसर प्लेबैक के दौरान अनुक्रम के ट्रैक्स में से एक या अधिक को म्यूट करने के लिए सेट किया जा सकता है ताकि उन निर्दिष्ट प्ले में कोई भी इंस्ट्रूमेंट न हो। निम्न उदाहरण म्यूट किए जाने वाले अनुक्रम में पहला ट्रैक सेट करता है:

import javax.sound.midi.Track;
// ...

Track[] track = sequence.getTracks();
sequencer.setTrackMute(track[0]);

अगर लूप काउंट दिया जाता है तो एक सीक्वेंसर बार-बार एक सीक्वेंस खेल सकता है। निम्नलिखित अनुक्रम को चार बार और अनिश्चित काल के लिए चलाने के लिए सेट करता है:

sequencer.setLoopCount(3);
sequencer.setLoopCount(Sequencer.LOOP_CONTINUOUSLY);

सीक्वेंसर को हमेशा शुरू से अनुक्रम नहीं खेलना होता है, और न ही इसे अंत तक अनुक्रम खेलना होता है। यह किसी भी बिंदु पर शुरू और अंत में टिक को निर्दिष्ट करके शुरू और समाप्त कर सकता है। यह मैन्युअल रूप से निर्दिष्ट करना भी संभव है कि अनुक्रम को किस क्रम में टिक करना चाहिए:

sequencer.setLoopStartPoint(512);
sequencer.setLoopEndPoint(32768);
sequencer.setTickPosition(8192);

सीक्वेंसर एक निश्चित टेंपो पर मिडी फाइल भी चला सकते हैं, जिसे प्रति मिनट बीपीएम (बीपीएम) या माइक्रोसेकंड प्रति तिमाही नोट (एमपीक्यू) में टेम्पो को निर्दिष्ट करके नियंत्रित किया जा सकता है। जिस कारक पर अनुक्रम खेला जाता है, उसे भी समायोजित किया जा सकता है।

sequencer.setTempoInBPM(1250f);
sequencer.setTempoInMPQ(4750f);
sequencer.setTempoFactor(1.5f);

जब आप Sequencer का उपयोग करना समाप्त कर लेते हैं, तो इसे बंद करने के लिए रीबेबर

sequencer.close();

नाद धातु ध्वनि

जावा के साथ ध्वनि उत्पन्न करते समय आप लगभग नंगे धातु भी जा सकते हैं। यह कोड ध्वनि उत्पन्न करने के लिए OS ऑडियो बफर में कच्चा बाइनरी डेटा लिखेगा। इस तरह ध्वनि उत्पन्न करने के लिए सीमाओं और आवश्यक गणनाओं को समझना बेहद महत्वपूर्ण है। चूंकि प्लेबैक मूल रूप से तात्कालिक है, गणना लगभग वास्तविक समय पर की जानी चाहिए।

जैसे कि यह विधि अधिक जटिल ध्वनि-नमूनाकरण के लिए अनुपयोगी है। ऐसे उद्देश्यों के लिए विशेष साधनों का उपयोग करना बेहतर दृष्टिकोण है।

निम्नलिखित विधि उत्पन्न करती है और सीधे किसी दिए गए आयतन की आयत-तरंग को किसी दी गई अवधि के लिए दिए गए आयतन में उत्पन्न करती है।

public void rectangleWave(byte volume, int hertz, int msecs) {
    final SourceDataLine dataLine;
    // 24 kHz x 8bit, single-channel, signed little endian AudioFormat
    AudioFormat af = new AudioFormat(24_000, 8, 1, true, false);
    try {
        dataLine = AudioSystem.getSourceDataLine(af);
        dataLine.open(af, 10_000); // audio buffer size: 10k samples
    } catch (LineUnavailableException e) {
        throw new RuntimeException(e);
    }

    int waveHalf = 24_000 / hertz; // samples for half a period
    byte[] buffer = new byte[waveHalf * 20];
    int samples = msecs * (24_000 / 1000); // 24k (samples / sec) / 1000 (ms/sec) * time(ms)

    dataLine.start(); // starts playback
    int sign = 1;

    for (int i = 0; i < samples; i += buffer.length) {
        for (int j = 0; j < 20; j++) { // generate 10 waves into buffer
            sign *= -1; 
            // fill from the jth wave-half to the j+1th wave-half with volume
            Arrays.fill(buffer, waveHalf * j, waveHalf * (j+1), (byte) (volume * sign));
        }
        dataLine.write(buffer, 0, buffer.length); // 
    }
    dataLine.drain(); // forces buffer drain to hardware
    dataLine.stop();  // ends playback
}

विभिन्न साउंडवेव्स साइनस गणनाओं को उत्पन्न करने के लिए अधिक विभेदित तरीके के लिए और संभवतः बड़े नमूना आकार आवश्यक हैं। यह काफी अधिक जटिल कोड में परिणाम है और तदनुसार यहाँ छोड़ दिया है।

मूल ऑडियो आउटपुट

हैलो ऑडियो! जावा की जो स्थानीय या इंटरनेट स्टोरेज से साउंड फाइल चलाती है, इस प्रकार दिखती है। यह असम्पीडित .wav फ़ाइलों के लिए काम करता है और एमपी 3 या संपीड़ित फ़ाइलों को चलाने के लिए उपयोग नहीं किया जाना चाहिए।

import java.io.*;
import java.net.URL;
import javax.sound.sampled.*;

public class SoundClipTest {

   // Constructor
   public SoundClipTest() {          
      try {
         // Open an audio input stream.           
          File soundFile = new File("/usr/share/sounds/alsa/Front_Center.wav"); //you could also get the sound file with an URL
          AudioInputStream audioIn = AudioSystem.getAudioInputStream(soundFile); 
          AudioFormat format = audioIn.getFormat();             
         // Get a sound clip resource.
         DataLine.Info info = new DataLine.Info(Clip.class, format);
         Clip clip = (Clip)AudioSystem.getLine(info);
         // Open audio clip and load samples from the audio input stream.
         clip.open(audioIn);
         clip.start();
      } catch (UnsupportedAudioFileException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (LineUnavailableException e) {
         e.printStackTrace();
      }
   }

   public static void main(String[] args) {
      new SoundClipTest();
   }
}