ravenscott-blog/markdown/pearCast: Decentralized Audio Broadcasting for the Free and Open Internet.md

<!-- lead -->
Empowering Open Communication Through Decentralized Audio Streaming

Control over information is both a powerful asset and a contentious issue. Centralized services hold significant sway over what content can be shared, placing constraints on open communication. But, with advancements in peer-to-peer (P2P) technology, we’re beginning to break down these walls. One powerful tool for this revolution is **pearCast**, an entirely decentralized, real-time audio broadcasting application that enables users to share audio without any centralized control.

pearCast uses **Hyperswarm** and the **Web Audio API** to allow anyone with internet access to broadcast audio directly to listeners, removing the need for servers and intermediaries. This P2P approach offers advantages like privacy, resilience against censorship, and enhanced freedom of communication. Built with **Pear CLI**, pearCast is accessible as a desktop application, empowering users with tools to sidestep centralized restrictions and create their own channels of communication.

# Source
## https://git.ssh.surf/snxraven/pearCast

## The Power of P2P Broadcasting

In a traditional client-server setup, broadcasters send their data to a central server, which then redistributes it to listeners. However, central servers can impose restrictions, leading to censorship or surveillance. pearCast changes this by adopting a P2P model: data flows directly between the broadcaster and each listener, avoiding central servers altogether.

This approach offers significant benefits:
1. **Freedom from Censorship**: In a P2P model, there’s no central authority that can restrict, alter, or monitor content.
2. **Enhanced Privacy**: With no central server logging or monitoring user activity, P2P connections enhance privacy.
3. **Resilience**: In pearCast, if one peer disconnects, the network remains operational. Broadcasters retain control and connections remain active for listeners who are still tuned in.

P2P connections are especially useful in regions where internet access is regulated, or in situations where people need a secure way to broadcast audio without surveillance. With pearCast, users can host a private radio station, hold secure discussions, or share music with friends, all without centralized oversight.

## Behind the Scenes: How pearCast Works

pearCast is powered by several key technologies: **Hyperswarm** for peer discovery and P2P connections, **Web Audio API** for capturing and streaming audio, and **Pear CLI** for running the app as a desktop application. Let’s break down how these technologies work together to create a smooth broadcasting experience.

### Hyperswarm: Building P2P Connections

Hyperswarm enables pearCast’s decentralized networking. It’s designed for building large, scalable P2P networks where users connect directly to one another, bypassing the need for servers. Hyperswarm operates over a Distributed Hash Table (DHT), allowing users to find each other based on a unique identifier, or “topic.” Here’s how it works in pearCast:

- **Creating a Station ID**: When a broadcaster creates a station, pearCast generates a unique `topic` using `crypto.randomBytes(32)`. This 32-byte random key becomes the station ID.
- **Joining a Station**: Listeners enter the station ID to connect. Hyperswarm uses the DHT to locate peers that are on the same topic, establishing direct connections.
- **Handling Connections**: Hyperswarm’s `swarm.on('connection')` event is triggered whenever a peer connects, enabling data streaming without the need for a central server. Each connection is secure and private, only accessible to those with the correct topic key.

This DHT-based discovery mechanism allows pearCast to function entirely independently of DNS or IP-based connections, enabling connections that are fast, efficient, and censorship-resistant.

### Web Audio API: Capturing and Streaming Audio

The **Web Audio API** provides pearCast with powerful tools for capturing, processing, and playing audio directly within the browser. The Web Audio API enables real-time audio streaming by capturing microphone input and encoding it for P2P transmission. Here’s how it works:

1. **Setting Up Audio Capture**: When a broadcaster starts a station, pearCast requests microphone access using `navigator.mediaDevices.getUserMedia()`. The chosen input device (e.g., the default microphone or any selected audio device) begins capturing audio in real time.
2. **Audio Processing**: The captured audio stream is sent to an `AudioContext` and processed by a `ScriptProcessorNode`, which allows pearCast to take chunks of audio data, encode them into `Float32Array` format, and transmit them over Hyperswarm.
3. **Playing Audio for Listeners**: When listeners receive audio data, pearCast uses the Web Audio API to decode the audio data and play it through an `AudioBufferSourceNode` connected to the `AudioContext`.

### Pear CLI: Running as a Desktop Application

Pear CLI is a tool for creating and managing P2P desktop applications. By running pearCast as a Pear application, users can connect to peers more reliably and bypass web-based limitations. Pear CLI provides a native experience for P2P applications, improving performance, stability, and connection resilience.

## Setting Up pearCast


## P2P Runtime

To run pearCast via the Pear network, simply run:

`npm i pear -g`

Then run:

`pear run pear://q3rutpfbtdsr7ikdpntpojcxy5u356qfczzgqomxqk3jdxn6ao8y`

To set up and use pearCast in a development environment, Here’s how you can get started:

1. **Clone the Repository**:
   ```bash
   git clone https://git.ssh.surf/snxraven/pearCast.git
   cd pearCast
   ```
2. **Install Dependencies**:
   ```bash
   npm install
   ```
3. **Run the Application**:
   ```bash
   pear run --dev .
   ```

Once the app is running, you can start broadcasting or join an existing station by entering the station ID. If you’re using a browser-based approach, you can serve `index.html` via a local server and access it through your preferred browser.

## Walkthrough of pearCast’s Code

Let’s dive into pearCast’s code to understand how each component works together to create this powerful P2P audio streaming experience.

### HTML Layout: index.html

The HTML layout in `index.html` is designed to be clean and intuitive. It includes the main controls for creating or joining a station, a modal for entering station IDs, and a dropdown for broadcasters to select their audio input.

Key Elements:
- **Create and Join Buttons**: Users can start a new broadcast station or join an existing one.
- **Audio Input Selector**: Only visible to broadcasters, this dropdown allows them to choose their preferred microphone input.
- **Bootstrap Modal**: Used to prompt users to enter a station ID when joining a broadcast.

### JavaScript Logic: app.js

The JavaScript in `app.js` handles all application logic, from establishing P2P connections to capturing and streaming audio data.

#### Setting Up Hyperswarm Connections

The following code sets up Hyperswarm connections for broadcasters and listeners:
```javascript
let swarm;
let topic = crypto.randomBytes(32);
swarm = new Hyperswarm();
swarm.join(topic, { client: false, server: true });

swarm.on('connection', (conn) => {
    // Handle incoming connection
});
```
This `topic` serves as a unique identifier for the station. Broadcasters join in server mode, while listeners join in client mode, enabling Hyperswarm to automatically discover peers.

#### Capturing and Streaming Audio with Web Audio API

Once a broadcaster creates a station, the app captures audio and processes it for streaming:
```javascript
navigator.mediaDevices.getUserMedia({ audio: { deviceId: currentDeviceId } })
    .then(stream => {
        const source = audioContext.createMediaStreamSource(stream);
        const processor = audioContext.createScriptProcessor(4096, 1, 1);

        source.connect(processor);
        processor.connect(audioContext.destination);

        processor.onaudioprocess = (event) => {
            const audioData = event.inputBuffer.getChannelData(0);
            const buffer = b4a.from(new Float32Array(audioData).buffer);
            conn.write(buffer);
        };
    });
```
This function:
1. **Requests Microphone Access**: Captures audio based on the selected input device.
2. **Processes Audio in Real Time**: The `ScriptProcessorNode` divides audio into chunks and encodes it as a `Float32Array`.
3. **Streams Audio to Listeners**: The broadcaster sends audio data to all connected peers over Hyperswarm.

#### Playing Audio for Listeners

Listeners receive audio data, decode it, and play it using the Web Audio API:
```javascript
function processIncomingAudioData(data) {
    accumulatedBuffer = b4a.concat([accumulatedBuffer, data]);

    while (accumulatedBuffer.byteLength >= 4) {
        const chunkSize = accumulatedBuffer.byteLength;
        const audioData = new Float32Array(accumulatedBuffer.slice(0, chunkSize).buffer);
        accumulatedBuffer = accumulatedBuffer.slice(chunkSize);

        const buffer = audioContext.createBuffer(1, audioData.length, audioContext.sampleRate);
        buffer.copyToChannel(audioData, 0);

        const source = audioContext.createBufferSource();
        source.buffer = buffer;
        source.connect(audioContext.destination);
        source.start();
    }
}
```
The function:
1. **Buffers Incoming Audio Data**: As data packets arrive, they’re stored until there’s enough for smooth playback.
2. **Decodes Audio Data**: Audio chunks are converted back into audio buffer format.
3. **Plays Audio in Real Time**: The data is played using an `AudioBufferSourceNode`.

#### Managing Peer Connections and Disconnects

pearCast handles connections and disconnects gracefully, avoiding crashes and logging disconnections:
```javascript
swarm.on

('connection', (conn) => {
    conn.once('close', () => {
        console.log("Peer disconnected.");
    });

    conn.on('error', (err) => {
        if (err.code === 'ECONNRESET') {
            console.log("Peer connection reset by remote peer.");
        } else {
            console.error("Connection error:", err);
        }
    });
});
```
By listening to connection events, pearCast ensures that disconnected peers are handled smoothly, enhancing the stability and resilience of the broadcast.

## Use Cases and Real-World Applications

The potential of pearCast goes beyond casual broadcasting. Some real-world applications include:

1. **Independent News Stations**: In regions where information is controlled, pearCast can be used to share uncensored news directly with listeners.
2. **Community Radio**: Local communities can create their own online radio stations without needing a central server.
3. **Private Discussions**: pearCast allows users to host private audio channels where discussions are free from surveillance or interference.
4. **Remote Music Jams**: Musicians can use pearCast to broadcast live performances, even in locations with limited internet access.

## Final Thoughts

pearCast is more than just a broadcasting app. It’s a testament to the power of decentralized technology and a step forward in the fight for communication freedom. By combining P2P networking with real-time audio streaming, pearCast empowers users to create their own audio platforms, share content securely, and circumvent traditional barriers to communication.

Whether you’re an activist, an artist, or simply a fan of free, uncensored broadcasting, pearCast gives you the tools to break free from central control and make your voice heard.