Panimula sa Pag-convert ng Audio

Sa mundo ng digital audio, maraming paraan upang i-save ang ating mga tunog. Ang bawat paraan ay may sariling espesyal na tampok, tulad ng pagpapaliit ng mga file o pagpapanatili ng tunog na talagang malinaw. Ngunit bakit napakarami? Well, dahil ang bawat isa ay may iba’t ibang pangangailangan at kagustuhan. Ang ilang mga format ay gumagana nang maayos para sa pagbabahagi ng musika online, habang ang iba ay pinakamahusay para sa mga recording sa studio.

Ngunit kung minsan, kailangan nating baguhin ang isang uri ng audio file sa isa pa. Marahil ang aming music player ay nagpe-play lamang ng isang uri ng file, ngunit mayroon kaming kanta sa ibang format. O marahil gusto naming makatipid ng espasyo sa aming computer sa pamamagitan ng pagpapaliit ng malalaking file. Dito pumapasok ang audio conversion. Ngayon, tuklasin natin ang mundo ng mga format ng audio at alamin kung paano madaling mag-convert mula sa isa patungo sa isa pa.

Karaniwang Mga Format ng Audio

MP3, WAV, AAC, FLAC, OGG: Pag-unawa sa Karaniwang Mga Format ng Audio

Bago tayo sumisid sa mga detalye ng pag-convert ng audio, tingnan muna natin ang ilan sa mga pinakakaraniwang format ng audio at kung saan mo sila maaaring makita:

• MP3 (MPEG-1 Audio Layer 3): Ang MP3 ay parang superstar ng mga format ng audio. Perpekto ito para sa pagbabahagi at pakikinig ng musika online dahil pinapaliit nito ang mga file nang hindi nawawalan ng masyadong kalidad. Kaya, kapag nag-download ka ng kanta mula sa internet, malamang na ito ay nasa format na MP3.

• WAV (Waveform Audio File Format): Ang WAV ay tungkol sa pagpapanatili ng mga bagay na sobrang linaw. Ito ang go-to format para sa mga propesyonal na recording ng audio dahil hindi nito kino-compress ang tunog, na nangangahulugang mahusay ito para sa paggawa ng musika sa isang studio.

• AAC (Advanced Audio Coding): Ang AAC ay ang format na ginagamit ng iTunes at Apple Music, kaya kapag bumili ka ng kanta mula sa iTunes Store, malamang na ito ay nasa format na AAC. Dagdag pa, ito rin ang default na format para sa pagre-record ng mga voice memo sa mga iPhone.

• FLAC (Free Lossless Audio Codec): Ang FLAC ay para sa mga audiophile na gustong makuha ang pinakamahusay sa parehong mundo: maliit na laki ng file at nangungunang kalidad ng tunog. Perpekto ito para sa pag-archive ng iyong mga paboritong album o pag-enjoy ng mataas na kalidad na musika sa iyong magarbong headphone.

• OGG (Ogg Vorbis): Ang OGG ay maaaring hindi kasing sikat ng iba, ngunit medyo cool pa rin ito. Ito ay isang open-source na format na mahusay para sa streaming ng musika online. Dagdag pa, mas maliit ito kaysa sa mga file ng MP3 at sumusuporta sa mga karagdagang tampok tulad ng metadata, na madaling gamitin para sa pag-oorganisa ng iyong library ng musika.

Paano Mag-convert ng mga Audio File - Mga Opsyon para sa Pag-convert ng Audio

Pag-convert ng Audio gamit ang Command Line

Maraming opsyon para sa pag-convert ng audio. Kung mas gusto mo ang mga GUI interface, maaari kang gumamit ng mga online audio converter o Audacity. Kung bukas ka sa pagdumi ng iyong mga kamay at hindi mo iniisip ang pagta-type, maaari mong gamitin ang SoX o GStreamer, na nag-aalok ng mas maraming flexibility. Dito, magtutuon ako sa GStreamer dahil sinusuportahan nito ang command line at programming nang maayos at natural na sinusuportahan ang streaming (o on-the-fly na conversion).

Pag-install ng GStreamer

Ang opisyal na website ng GStreamer ay nagbibigay ng detalyadong mga tagubilin sa pag-install para sa iba’t ibang operating system, tingnan dito. Gumagana rin ang sumusunod.

Para sa mga sistemang Linux, maaari mong gamitin ang mga package manager. Halimbawa, para sa mga sistemang batay sa Debian/Ubuntu, kailangan mo lang gawin:

sudo apt install gstreamer1.0
sudo apt install gstreamer1.0-plugins-base
sudo apt install gstreamer1.0-plugins-good gstreamer1.0-plugins-bad gstreamer1.0-plugins-ugly

Ang pangalawa at pangatlong utos ay opsyonal ngunit palagi kong nakikita na nakakatulong ang pag-install ng mga karagdagang plugin na ito.

Para sa MacOS, maaari kang mag-install sa pamamagitan ng Homebrew. Katulad ng mga utos ng Linux, ginagawa mo:

brew install gstreamer

Ang Homebrew ay hindi nagbibigay ng hiwalay na mga pakete para sa mga plugin ng Gstreamer na “good”, “bad” at “ugly” tulad ng ginagawa nito para sa mga distribusyon ng Linux. Sa halip, karaniwang nag-i-install ang Homebrew ng isang set ng mga plugin bilang bahagi ng gstreamer package mismo.

Para sa Windows, may mga pre-compiled installer, pumunta sa dokumentasyon ng GStreamer dito at sundin ang mga tagubilin.

Pag-convert ng Audio

Kapag na-install mo na ang GStreamer, medyo diretso ang pag-convert mula sa isang format ng audio patungo sa isa pa. Ipagpalagay na mayroon kang isang audio file sa format na MP3, pangalanan natin itong input.mp3, at gusto mong i-convert ito sa format na WAV, pangalanan natin itong output.wav, patakbuhin mo lang ang sumusunod na command:

gst-launch-1.0 filesrc location=input.mp3 ! decodebin ! audioconvert ! audioresample ! wavenc ! filesink location=output.wav

Ginagamit ng command na ito ang sumusunod na mga elemento ng GStreamer:

• filesrc: Nagbabasa ng data mula sa isang file.
• decodebin: Awtomatikong nakikita at nagde-decode ng format ng audio ng input file.
• audioconvert: Nagko-convert ng format ng audio sa isang format na angkop para sa conversion.
• audioresample: Nagre-resample ng audio sa nais na sample rate, kung kinakailangan.
• wavenc: Nag-e-encode ng data ng audio sa format na WAV.
• filesink: Nagsusulat ng output audio data sa isang file.

Kapag pinatakbo mo ang command na ito, babasahin ng GStreamer ang input MP3 file, ide-decode ito, iko-convert ito sa format na WAV, at ise-save ang resultang WAV file sa tinukoy na lokasyon.

Maaari mong tukuyin ang mga detalye ng format ng WAV gamit ang elemento ng audioconvert. Narito ang isang halimbawa na nagtatakda ng sample rate sa 44100 Hz at mga channel sa stereo:

gst-launch-1.0 filesrc location=input.mp3 ! decodebin ! audioconvert ! audio/x-raw,format=S16LE,rate=44100,channels=2 ! wavenc ! filesink location=output.wav

Katulad nito, maaari kang mag-convert mula sa isang uri patungo sa isa pa gamit ang iba’t ibang mga plugin ng GStreamer.

Pag-convert ng Audio On the Fly

Ang pag-convert ng audio on the fly, o real-time na pag-convert ng audio, ay mahalaga sa iba’t ibang sitwasyon ng pagproseso ng audio. Upang banggitin lamang ang ilan:

• Streaming Adaptability: Kapag nag-stream ng nilalaman ng audio sa mga network, ang iba’t ibang device at platform ay maaaring magkaroon ng iba’t ibang kinakailangan para sa mga format ng audio at codec. Tinitiyak ng real-time na conversion ang tuluy-tuloy na streaming adaptability sa pamamagitan ng dynamic na pag-aayos ng data ng audio upang tumugma sa mga detalye ng bawat tumatanggap na device o platform. Mahalaga ang adaptability na ito para matiyak ang maayos na pag-playback sa iba’t ibang kapaligiran nang hindi nangangailangan ng pre-processing o re-encoding.
• Low-Latency Transmission: Sa mga interactive na application tulad ng voice communication, online gaming, o live events, ang pagliit ng latency ay mahalaga para mapanatili ang real-time na pagtugon at pakikipag-ugnayan ng user. Ang paggawa ng audio conversion on the fly ay nagpapahintulot sa data ng audio na maipadala nang may kaunting pagkaantala, na tinitiyak ang halos agarang paghahatid at pag-playback. Pinapahusay ng low-latency transmission na ito ang pangkalahatang karanasan ng user, lalo na sa mga application na sensitibo sa oras kung saan ang pagtugon ay pinakamahalaga.
• Resource Efficiency: Ang real-time na audio conversion ay nagtitipid ng mga mapagkukunan ng system sa pamamagitan ng pag-iwas sa pangangailangan para sa pag-iimbak o pagproseso ng malalaking audio file nang maaga. Sa halip na i-pre-convert ang nilalaman ng audio sa iba’t ibang format, ang conversion on the fly ay nagpapahintulot sa mga mapagkukunan na maitalaga nang dynamic kung kinakailangan, na binabawasan ang mga kinakailangan sa imbakan at overhead ng pagproseso. Ang resource-efficient na diskarte na ito ay partikular na kapaki-pakinabang sa mga kapaligiran na limitado ang mapagkukunan, tulad ng mga naka-embed na system o mobile device, kung saan ang pag-optimize ng paggamit ng mapagkukunan ay mahalaga para mapanatili ang pagganap at scalability.

Sa aming partikular na kaso ng paggamit, mayroon kaming software ng katalinuhan sa pag-uusap na tinatawag na SeaMeet na tumatanggap ng mga audio file o stream (hal., Google Meet) sa iba’t ibang format ng audio at nagta-transcribe ng pag-uusap mula sa pagsasalita patungo sa teksto. Kaya, kailangan naming i-convert ang audio sa iba’t ibang format sa isang format na gumagana sa aming speech recognition engine on the fly.

Ang on-the-fly o real-time na pag-convert ng audio ay maaaring makamit gamit ang GStreamer library. Katulad ng command, kailangan nating ayusin ang mga plugin ng GStreamer sa isang streaming conversion pipeline, ngunit sa pagkakataong ito, gamit ang isang programming language.

I-post muna natin ang isang gumaganang halimbawa sa Python, at ipapaliwanag namin kung paano ito gumagana.

#!/usr/bin/python3

import gi
gi.require_version('Gst', '1.0')
from gi.repository import Gst
import threading
import queue
import time

# Initialize GStreamer
Gst.init(None)

class AudioConverter:
    """
    Converts different audio to PCM in real-time or faster, depending on options.

    Attributes:
        pipeline (Gst.Pipeline): The GStreamer pipeline for processing audio.
        appsrc (Gst.Element): The appsink element for feeding data to the pipeline.
        decodebin (Gst.Element): The decodebin element for decoding different audio.
        audioconvert (Gst.Element): The audioconvert element for format conversion.
        audioresample (Gst.Element): The audioresample element for adjusting sample rate (optional).
        outputformat (Gst.Element): The outputformat element to set output format.
        appsink (Gst.Element): The appsink element for receiving converted data.
        input_queue (queue.Queue): Queue for input audio data chunks.
        output_queue (queue.Queue): Queue for output PCM data chunks.
        thread (threading.Thread): Thread for reading input data and running pipeline.
        options (dict): Dictionary containing configuration options.

    Options:
        sync (bool, default=True): Whether to synchronize appsink with pipeline clock (real-time processing).
        preroll (bool, default=False): Preroll the pipeline before processing data.

    Methods:
        push_data(data_chunk): Pushes an audio data chunk to the input queue.
        pull_converted_data(): Retrieves a converted PCM data chunk from the output queue.
        run(): Starts the pipeline and data processing thread.
        on_pad_added(element, pad): Connects elements in the pipeline.
        new_sample_callback(appsink): Receives newly converted data and adds it to the output queue.
        on_message(bus, message): Handles pipeline messages (EOS, error).
    """

    def __init__(self, options=None):
        """
        Initializes the AudioConverter with default or provided options.
        """
        self.options = options or {}

        # Set default values for all options
        self.options.setdefault("sync", True)
        self.options.setdefault("preroll", False)
        self.options.setdefault("output_format", "audio/x-raw,format=S16LE,rate=16000,channels=1")

        self.pipeline = Gst.Pipeline()

        self.appsrc = Gst.ElementFactory.make("appsrc", "appsrc")
        self.decodebin = Gst.ElementFactory.make("decodebin", "decodebin")
        self.audioconvert = Gst.ElementFactory.make("audioconvert", "audioconvert")
        self.audioresample = Gst.ElementFactory.make("audioresample", "audioresample")
        self.outputformat = Gst.ElementFactory.make("capsfilter", "outputformat")
        self.outputformatcaps = Gst.Caps.from_string(self.options["output_format"])
        self.outputformat.set_property("caps", self.outputformatcaps)
        self.appsink = Gst.ElementFactory.make("appsink", "appsink")

        # Add elements to the pipeline
        self.pipeline.add(self.appsrc)
        self.pipeline.add(self.decodebin)
        self.pipeline.add(self.audioconvert)
        self.pipeline.add(self.audioresample)
        self.pipeline.add(self.outputformat)
        self.pipeline.add(self.appsink)

        # Link elements together
        self.appsrc.link(self.decodebin)
        self.decodebin.connect("pad-added", self.on_pad_added)
        self.audioconvert.link(self.audioresample)
        self.audioresample.link(self.outputformat)
        self.outputformat.link(self.appsink)

        # Set appsink properties
        self.appsink.set_property("emit-signals", True)
        self.appsink.connect("new-sample", self.new_sample_callback)
        if not self.options["sync"]:
            self.appsink.set_property("sync", False)

        # Create input and output queues based on options
        self.input_queue = queue.Queue()
        self.output_queue = queue.Queue()

        self.thread = threading.Thread(target=self.run)
        self.thread.start()

    def push_data(self, data_chunk):
        self.input_queue.put(data_chunk)

    def pull_converted_data(self):
        if not self.output_queue.empty():
            return self.output_queue.get(block=False)  # Wait for data or None
        else:
            return None

    def run(self):
        """
        Starts the pipeline and data processing thread.
        """

        self.pipeline.set_state(Gst.State.PLAYING)
        bus = self.pipeline.get_bus()
        bus.add_signal_watch()
        bus.connect("message", self.on_message)

        # Preroll pipeline if enabled
        if self.options["preroll"]:
            while True:
                msg = bus.timed_pop(Gst.MessageType.ELEMENT, Gst.CLOCK_TIME_NONE)
                if msg is not None:
                    break
            self.pipeline.set_state(Gst.State.NULL)

        while True:
            while self.input_queue.empty():  # Wait for data if the queue is empty
                time.sleep(0.01)

            data_chunk = self.input_queue.get(block=False)  # Wait for data or None
            if data_chunk is None:
                self.appsrc.emit("end-of-stream")
                break  # End of data received

            self.process_data(data_chunk)

        # Wait for the EOS message
        bus.poll(Gst.MessageType.EOS | Gst.MessageType.ERROR, Gst.CLOCK_TIME_NONE)
        self.pipeline.set_state(Gst.State.NULL)

    def process_data(self, data_chunk):
        if data_chunk is None:
            return False

        self.appsrc.emit("push-buffer", Gst.Buffer.new_wrapped(data_chunk))
        return True

    def on_pad_added(self, element, pad):
        if pad.query_caps(None).to_string().startswith("audio/"):
            pad.link(self.audioconvert.get_static_pad("sink"))

    def new_sample_callback(self, appsink):
        sample = appsink.emit("pull-sample")
        if sample:
            buffer = sample.get_buffer()
            data_chunk = buffer.extract_dup(0, buffer.get_size())
            self.output_queue.put(data_chunk)
            print("Data Converted")

        return Gst.FlowReturn.OK

    def on_message(self, bus, message):
        t = message.type
        if t == Gst.MessageType.EOS:
            print("End of stream")
            self.output_queue.put(None)  # Signal end of stream to downstream
            self.pipeline.set_state(Gst.State.NULL)
        elif t == Gst.MessageType.ERROR:
            err, debug = message.parse_error()
            print("Error: %s" % err, debug)
            self.pipeline.set_state(Gst.State.NULL)

    def pipeline_reached_eos(self):
        """
Checks if the pipeline has reached EOS.
"""
        return not self.pipeline or self.pipeline.get_state(Gst.CLOCK_TIME_NONE)[1] == Gst.State.NULL

def main():
    # Create an AudioConverter instance
    converter = AudioConverter(options={"sync": False,
        "output_format": "audio/x-raw,format=S16LE,rate=16000,channels=1"})

    CHUNK_SIZE = 1024  # Adjust as needed
    with open("input.mp3", "rb") as infile, \
         open("output.pcm", "wb") as outfile:

        while True:
            # Read a chunk of data from the input file
            data_chunk = infile.read(CHUNK_SIZE)
            if not data_chunk:
                converter.push_data(None)    # Push stream end.
                break

            # Push the data chunk to the converter
            print("Data Push")
            converter.push_data(data_chunk)

            # Attempt to pull any converted data immediately
            converted_chunk = converter.pull_converted_data()
            while converted_chunk is not None:
                outfile.write(converted_chunk)
                converted_chunk = converter.pull_converted_data()

            # Calculate sleep time based on processed audio duration
            audio_duration = 0.05
            time.sleep(audio_duration)

        # Flush out the remaining data from the pipeline.
        while not converter.pipeline_reached_eos():
            converted_chunk = converter.pull_converted_data()
            while converted_chunk is not None:
                outfile.write(converted_chunk)
                converted_chunk = converter.pull_converted_data()
            # time.sleep(0.01)
        converted_chunk = converter.pull_converted_data()
        if converted_chunk is not None:
            outfile.write(converted_chunk)

        # Flush any remaining data to the output file
        outfile.flush()


    # Signal end of input data and wait for completion
    converter.thread.join()

if __name__ == "__main__":
    main()

## Ang Klase ng “AudioConverter”
Ang klase ng AudioConverter ay ang pangunahing paggana para sa real-time na pag-convert ng format ng audio sa code na ito. Hatiin natin kung paano nito ginagamit ang isang pipeline ng GStreamer upang makamit ito.

Ang mga pangunahing plugin ng Gstreamer at ang daloy ng data ay ang mga sumusunod:
1. Ang mga chunk ng data ng audio ay itinutulak mula sa programang Python patungo sa `appsrc`.
2. Ang `appsrc` ay nag-i-inject ng data sa pipeline.
3. Ang `decodebin` ay awtomatikong nakikita at nagde-decode ng papasok na format ng audio.
4. Ang `audioconvert` ay nagsasagawa ng pag-convert ng format sa PCM.
5. Ang `audioresample` (kung pinagana) ay nag-a-adjust ng sample rate.
6. Ang `outputformat` ay nagsisiguro na ang data ay tumutugma sa nais na format ng PCM.
7. Ang `appsink` ay tumatanggap ng na-convert na data ng PCM at nagbibigay ng mekanismo ng callback para sa programang Python upang makuha ito.

Sa madaling salita, tumatanggap ito ng data ng audio nang paisa-isa gamit ang `appsrc`, kino-convert ang data ng audio at pagkatapos ay ipinapadala ang data nang paisa-isa gamit ang `appsink`.

Ang ilang mahahalagang pamamaraan para sa klase ng `AudioConverter` ay:
- `on_pad_added`: Ang callback function na ito ay nagti-trigger kapag may bagong pad (data connection point) na available sa isang elemento. Partikular itong nagche-check para sa isang pad mula sa decodebin at ini-link ito sa audioconvert upang hawakan ang na-decode na data ng audio.
- `new_sample_callback`: Ang function na ito ay tinatawag ng appsink tuwing may bagong sample (na-convert na PCM data chunk) na available. Kinukuha nito ang data mula sa sample buffer at idinadagdag ito sa output queue para ma-access ng programang Python.
- `on_sample_callback`: Ang function na ito ay tinatawag ng appsink tuwing may bagong sample (na-convert na PCM data chunk) na available. Kinukuha nito ang data mula sa sample buffer at idinadagdag ito sa output queue para ma-access ng programang Python.
- `on_message`: Ang function na ito ay humahawak ng mga mensahe ng GStreamer na natanggap sa bus ng pipeline. Nakikinig ito para sa mga mensahe tulad ng End-of-Stream (EOS) o mga error. Sa EOS, sinisinyasan nito ang pagtatapos sa programa at nililinis ang pipeline. Ang mga error ay naka-log para sa mga layunin ng pag-debug.

Ang klase ng AudioConverter ay gumagamit ng pipeline at mga paggana ng elemento ng GStreamer upang makamit ang real-time na pag-convert ng format ng audio. Ang mga elemento ng GStreamer ay humahawak sa pagde-decode, pag-convert, at pag-package ng data ng audio, habang ang klase ay nagbibigay ng mga pamamaraan para sa interaksyon at pagpapalitan ng data sa programang Python.

### Ang Function ng “main”

Ang function na `main` ay nag-simulate ng real-time na audio streaming at nagpapakita kung paano gamitin ang klase ng `AudioConverter`. Maaari mong isulat ang iyong sariling wrapper function para sa klase ng `AudioConverter` ngunit ilang mahahalagang punto:

#### Pagproseso na Batay sa Chunk
Hindi tulad ng pagbabasa ng buong audio file nang sabay-sabay, binabasa ng code ang data sa mas maliliit na chunk (CHUNK_SIZE). Ginagaya nito kung paano maaaring matanggap ang data ng audio sa isang tuloy-tuloy na stream sa isang network o mula sa isang live na source.

#### Hindi Pag-block ng Pagkuha ng Data
Pagkatapos itulak ang isang input chunk, sinusubukan ng code na hilahin ang anumang na-convert na data na agad na available gamit ang pull_converted_data. Ginagaya nito kung paano maaaring kailanganin ng isang streaming application na iproseso at posibleng i-play muli ang na-convert na audio sa lalong madaling panahon, nang hindi naghihintay na ma-convert ang buong file.

#### Pag-sleep para sa Potensyal na Paghabol
Ang kinakalkulang oras ng pagtulog, bagaman malamang na hindi perpekto, ay nagpapakilala ng pagkaantala sa pagitan ng pagtulak ng bagong data at pagsubok na hilahin ang na-convert na data. Ginagaya nito ang potensyal na oras na maaaring kailanganin ng converter (GStreamer pipeline) upang iproseso ang natanggap na chunk. Nagbibigay ito ng oras sa converter upang makahabol bago ito pakainin ng mas maraming data.

# Bakit mo gagawin ang lahat nang mag-isa?

Bagama't mahalaga ang pag-convert ng mga audio file sa iba't ibang format, bakit titigil doon? Pagandahin ang iyong karanasan sa audio gamit ang [SeaMeet](https://seameet.ai/?utm_source=blog).

**Nag-aalok ang SeaMeet ng tumpak, real-time na transkripsyon at mga buod para sa lahat ng iyong pangangailangan sa audio.** Kung nagko-convert ka man ng mga audio file, nagre-record ng podcast, o gusto mo lang magkaroon ng transkripsyon ng pag-uusap, nagbibigay ang SeaMeet ng instant, mataas na kalidad na mga transkripsyon at insightful na mga buod. Ang makapangyarihang tool na ito ay makakatipid sa iyo ng mga oras ng manual na trabaho at makakatulong sa iyo na makuha ang pinakamataas na halaga mula sa iyong nilalaman ng audio.

[Mag-sign up para sa SeaMeet ngayon](https://seameet.ai/?utm_source=blog) at maranasan ang kagalakan ng pagsubaybay sa iyong pag-uusap.

# Higit pa mula sa Serye ng Audio Toolbox

- [Paano Mag-download ng Data ng Audio mula sa YouTube, Isa at Maraming Video](https://seasalt.ai/blog/65-how-to-download-audio-from-youtube/?utm_source=blog)