Is it possible to continuously stream audio data to speaker

[mattfeury]

Hello all,

I'm looking at the VAPIX Audio API, specifically the Transmit Audio Data section.

I am able to successfully send a request with a predefined audio chunk and here it play out of the speaker. What i'm interested in is to continuously stream data to the speaker so that it can play continuously in real-time. Is this possible? My testing keeps the socket open and I continuously pump data to it, but I do not hear anything from the speaker.

here is some sample code to show what i'm trying. this takes an mp3 file and loops it continuously:

import requests
from requests.auth import HTTPBasicAuth, HTTPDigestAuth
from pydub import AudioSegment
import audioop
import io
import numpy as np
import threading
import time
from queue import Queue
from urllib3.util.retry import Retry
from requests.adapters import HTTPAdapter

class AxisAudioStreamer:
    def __init__(self, axis_ip, mp3_path, username=None, password=None, chunk_duration_ms=100):
        """
        Initialize the audio streamer
        
        Args:
            axis_ip (str): IP address or hostname of Axis device
            mp3_path (str): Path to MP3 file to stream
            username (str, optional): Username for authentication
            password (str, optional): Password for authentication
            chunk_duration_ms (int): Duration of each audio chunk in milliseconds
        """
        self.url = f"http://{axis_ip}/axis-cgi/audio/transmit.cgi"
        self.auth = HTTPDigestAuth(username, password)
        self.chunk_duration_ms = chunk_duration_ms
        self.should_stream = False
        self.stream_thread = None
        
        # Load and prepare audio
        audio = AudioSegment.from_mp3(mp3_path)
        # Convert to mono if stereo
        if audio.channels > 1:
            audio = audio.set_channels(1)
        # Convert to 8000 Hz for G711
        self.audio = audio.set_frame_rate(8000)
        
        # Create session with retry strategy
        self.session = requests.Session()
        retries = Retry(total=5,
                       backoff_factor=0.1,
                       status_forcelist=[500, 502, 503, 504])
        self.session.mount('http://', HTTPAdapter(max_retries=retries))
        
        # Calculate bytes per chunk
        self.samples_per_chunk = int(8000 * (chunk_duration_ms / 1000.0))
        
    def _prepare_audio_chunks(self):
        """Convert entire audio file to G711 chunks"""
        samples = np.array(self.audio.get_array_of_samples())
        
        # Split into chunks
        chunks = [samples[i:i + self.samples_per_chunk] 
                 for i in range(0, len(samples), self.samples_per_chunk)]
        
        # Convert each chunk to G711
        g711_chunks = []
        for chunk in chunks:
            # Ensure chunk is the right size
            if len(chunk) < self.samples_per_chunk:
                # Pad with silence if needed
                chunk = np.pad(chunk, (0, self.samples_per_chunk - len(chunk)))
            
            # Convert to bytes then G711
            raw_chunk = chunk.tobytes()
            g711_chunk = audioop.lin2ulaw(raw_chunk, 2)  # 2 bytes per sample
            g711_chunks.append(g711_chunk)
            
        return g711_chunks

    def _stream_audio(self):
        """Internal method to handle the streaming"""
        chunks = self._prepare_audio_chunks()
        
        try:
            # Start streaming request
            response = self.session.post(
                self.url,
                data=self._chunk_generator(chunks),
                headers={'Content-Type': 'audio/basic'},
                auth=self.auth,
                stream=True  # Important for continuous streaming
            )
            
            if not response.ok:
                print(f"Streaming failed with status code: {response.status_code}")
                return
                
        except Exception as e:
            print(f"Streaming error: {str(e)}")
            self.should_stream = False

    def _chunk_generator(self, chunks):
        """Generator to yield audio chunks with proper timing"""
        while self.should_stream:
            for chunk in chunks:
                if not self.should_stream:
                    break
                    
                yield chunk
                
                # Sleep for chunk duration
                time.sleep(self.chunk_duration_ms / 1000.0)
                
    def start_streaming(self):
        """Start the audio stream"""
        if self.stream_thread and self.stream_thread.is_alive():
            print("Stream already running")
            return
            
        self.should_stream = True
        self.stream_thread = threading.Thread(target=self._stream_audio)
        self.stream_thread.daemon = True
        self.stream_thread.start()
        print("Streaming started")
        
    def stop_streaming(self):
        """Stop the audio stream"""
        self.should_stream = False
        if self.stream_thread:
            self.stream_thread.join()
        print("Streaming stopped")

# Create the streamer
streamer = AxisAudioStreamer(
    axis_ip="192.168.1.1",
    mp3_path="samplelmp3",
    username="username",
    password="password",
    chunk_duration_ms=100  # Adjust this based on your needs
)

# Start streaming
streamer.start_streaming()

# Let it run for a while
try:
    while True:
        time.sleep(1)
except KeyboardInterrupt:
    # Stop streaming when Ctrl+C is pressed
    streamer.stop_streaming()

Thank you

[github-actions[bot]]

This automatically generated reply acts as a friendly reminder.

Answers to your questions will most often come from the community, from developers like yourself. You will, from time to time, find that Axis employees answers some of the questions, but this is not a guarantee. Think of the discussion forum as a complement to other support channels, not a replacement to any of them.

If your question remains unanswered for a period of time, please revisit it to see whether it can be improved by following the guidelines listed in Axis support guidelines.

[vivekatoffice]

Hi @mattfeury ,
I hope you have checked the following:
570

I use the following FFmpeg command to stream the songs:

ffmpeg.exe -i "s1.mp3" -probesize 32 -analyzeduration 32 -c:a pcm_mulaw -ab 128k -ac 1 -ar 16000 -f wav -chunked_post 0 -content_type audio/axis-mulaw-128 http://root:pass@10.176.13.53/axis-cgi/audio/transmit.cgi

I understand you can loop the song with FFmpeg :

[mattfeury]

hello @vivekatoffice, thanks for the response. it was helpful and i can now see that i can send audio data in real time. however i'm noticing that around ~10seconds into the stream, the sound starts to degrade and eventually stop.

e.g. i tested your ffmpeg command (with an input from the microphone so it is properly streaming in real time), and it sounds good for about 10-15 seconds and then starts to get choppy before stopping altogether. the request stays open and doesn't seem to show any error (data continues to be transmitted, just not played)

ffmpeg -loglevel debug -f avfoundation -i ":1" -probesize 32 -analyzeduration 32 -c:a pcm_mulaw -ab 128k -ac 1 -ar 16000 -f wav -chunked_post 0 -content_type audio/axis-mulaw-128 http://username:pw@IP_address/axis-cgi/audio/transmit.cgi

i've upgraded to the latest firmware but still seeing this issue.

[rocky-ji]

Can you try the OS 11.11LTS? I tested this on my C1310 with 11.11.126, works fine with AMC.

ffmpeg.exe -i "Korea.wav" -probesize 32 -analyzeduration 32 -c:a pcm_mulaw -ab 128k -ac 1 -ar 16000 -f wav -chunked_post 0 -content_type audio/axis-mulaw-128 http://root:pass@192.168.1.110/axis-cgi/audio/transmit.cgi

[rocky-ji]

it is impossible to upload the wav file, so i just change it to txt, you need rename it to korea.wav and try Korea.wav.txt

[mattfeury]

thanks @rocky-ji . i am able to send a pre-recorded file over transmit.cgi – because the entire file is sent at once. this works fine.

what i'm trying to do is stream data in real time from one audio source to the speaker. that's why i'm using the microphone input on my ffmpeg command above. it should take the samples as they arrive, convert them to mulaw, and then send them. this works great for a few seconds until the sound cuts out. if i send the samples in bigger "chunk sizes", then it works for longer, but it still eventually cuts out. it feels like a potential issue around audio buffers or race conditions on the axis side.

i'm not sure why others are unable to reproduce it either which is more frustrating for me. i've tried multiple Axis OSes and multiple Axis products.

[rocky-ji]

You need first make sure the OS version works with the long wav file, then on that OS it should also works for your application.

In Axis media control audio sample, it also supports stream the computers micphone to speaker, so you can capture the packet and understand how it is implemented.

https://developer.axis.com/vapix/audio-systems/audio-api#transmit-audio-data

[mattfeury]

thanks @rocky-ji . i can confirm that i can send a single wav file over a single http request - this is all working as expected. your ffmpeg command works great for me, because it sends the audio data all at once. it's when i'm trying to stream audio input (e.g. from a realtime source like a microphone) that the audio begins to stutter out after a few seconds. the request stays alive and the server seems to process the incoming audio data, but the speaker seems to stop playing audio. it feels related to some buffer size or chunk size issue. this is all using the transmit.cgi functionality.

i'm not familiar with "Axis media control audio". is that a different API i can use to stream data?

[tpatora]

Hello,
I think the workaround for this problem is to use the SIP protocol available in the speaker.

[mattfeury]

Hello, I think the workaround for this problem is to use the SIP protocol available in the speaker.

thanks @tpatora. i was sort of thinking the same, but wanted to at least find out if i was crazy or this was an existing bug. have you encountered this before?

i did verify that SIP connections do not have this issue.

[tpatora]

I tested sending audio to speakers with IP-PBX Asterisk and it worked without any problems.But, I didn't check very long recordings