Python向Icecast服务器流式传输音频的正确方法

import requests
import time
from base64 import b64encode

class IcecastClient:
    def __init__(self, host, port, mount, user, password, audio_info):
        self.host = host
        self.port = port
        self.mount = mount
        self.user = user
        self.password = password
        self.audio_info = audio_info  # Additional audio information, e.g., 'samplerate=44100;channels=2;bitrate=128'
        self.stream_url = f"http://{host}:{port}{mount}"
        self.headers = {}
        self.session = requests.Session() # Use a session for persistent connections

    def connect(self):
        # Basic Auth Header
        auth_header = b64encode(f"{self.user}:{self.password}".encode()).decode("ascii")
        self.headers = {
            'Authorization': f'Basic {auth_header}',
            'Content-Type': 'audio/mpeg', # Assuming MP3, adjust for other formats
            'Ice-Public': '1',
            'Ice-Name': 'Auralyra Stream',
            'Ice-Description': 'Streaming with Auralyra',
            'Ice-Genre': 'Various',
            'Ice-Audio-Info': self.audio_info # e.g., 'samplerate=44100;channels=2;bitrate=128'
        }
        self.session.headers.update(self.headers) # Apply headers to the session

    def stream_audio_file(self, file_path, chunk_size=4096, bitrate_kbps=128):
        """
        Stream an audio file to Icecast, respecting playback speed.
        Args:
            file_path (str): Path to the audio file.
            chunk_size (int): Size of each audio chunk to read (bytes).
            bitrate_kbps (int): Assumed bitrate of the audio file in kilobits per second.
                                This is crucial for calculating sleep duration.
        """
        if not self.session.headers:
            print("Client not connected. Call connect() first.")
            return

        bytes_per_second = (bitrate_kbps * 1000) / 8 # Convert kbps to bytes per second

        with open(file_path, 'rb') as audio_file:
            print(f"Starting to stream {file_path} to {self.stream_url}")
            try:
                # Initial PUT request to establish the stream
                # For a continuous stream, it's often better to send the first chunk
                # with the PUT request and then subsequent chunks via the same connection.
                # requests.put with 'stream=True' might be needed for very large files,
                # but for chunked sending, simply using data=chunk in a loop is common.

                # The first chunk might be sent as part of the initial PUT
                # subsequent chunks keep the connection alive.
                # For simplicity here, we'll send all chunks in the loop.

                while True:
                    chunk = audio_file.read(chunk_size)
                    if not chunk:
                        print("End of file reached.")
                        break  # End of file

                    # Calculate the duration this chunk represents
                    if bytes_per_second > 0:
                        chunk_duration_seconds = len(chunk) / bytes_per_second
                    else:
                        chunk_duration_seconds = 0.01 # Avoid division by zero, small default sleep

                    start_time = time.time()

                    response = self.session.put(self.stream_url, data=chunk, stream=True) # stream=True for chunked sending

                    if response.status_code not in [200, 201]: # 201 Created might also be returned
                        print(f"Streaming failed: {response.status_code} - {response.reason}")
                        print(f"Response text: {response.text}")
                        break

                    # Calculate actual time taken to send the chunk
                    elapsed_time = time.time() - start_time

                    # Sleep for the remaining duration to match playback speed
                    sleep_duration = chunk_duration_seconds - elapsed_time
                    if sleep_duration > 0:
                        time.sleep(sleep_duration)
                    # else: # If sending took longer than chunk duration, no sleep needed
                        # print(f"Warning: Sending chunk took {elapsed_time:.4f}s, which is longer than its {chunk_duration_seconds:.4f}s duration.")

            except requests.RequestException as e:
                print(f"Error while sending audio chunk: {e}")
            except Exception as e:
                print(f"An unexpected error occurred: {e}")
            finally:
                print("Streaming process finished.")
                # It's good practice to explicitly close the session if done,
                # though requests.Session context manager handles it usually.
                # self.session.close() 

    def send_audio_chunk(self, audio_chunk):
        """
        Sends a single audio chunk. This method assumes external timing control.
        """
        if not self.session.headers:
            print("Client not connected. Call connect() first.")
            return
        try:
            response = self.session.put(self.stream_url, data=audio_chunk, stream=True)
            if response.status_code not in [200, 201]:
                print(f"Streaming failed: {response.status_code} - {response.reason}")
                print(f"Response text: {response.text}")
            # else:
            #     print(f"Chunk sent successfully. Status: {response.status_code}")
        except requests.RequestException as e:
            print(f"Error while sending audio chunk: {e}")
        except Exception as e:
            print(f"An unexpected error occurred: {e}")

# --- 使用示例 ---
if __name__ == "__main__":
    # 替换为你的Icecast服务器信息
    ICECAST_HOST = "localhost"
    ICECAST_PORT = 8000
    ICECAST_MOUNT = "/mystream.mp3"
    ICECAST_USER = "source"
    ICECAST_PASSWORD = "hackme"

    # 假设音频信息，对于MP3通常是固定的比特率
    # 确保这里的比特率与你实际要流式传输的MP3文件匹配
    AUDIO_BITRATE_KBPS = 128 
    AUDIO_INFO = f"samplerate=44100;channels=2;bitrate={AUDIO_BITRATE_KBPS}"

    # 创建一个测试用的MP3文件 (你需要准备一个实际的MP3文件)
    # 例如: test_audio.mp3
    TEST_AUDIO_FILE = "test_audio.mp3" 

    client = IcecastClient(
        host=ICECAST_HOST,
        port=ICECAST_PORT,
        mount=ICECAST_MOUNT,
        user=ICECAST_USER,
        password=ICECAST_PASSWORD,
        audio_info=AUDIO_INFO
    )

    client.connect()
    client.stream_audio_file(TEST_AUDIO_FILE, bitrate_kbps=AUDIO_BITRATE_KBPS)

    # 如果要实现更复杂的实时音频源（如麦克风输入），
    # 你会持续生成audio_chunk并调用client.send_audio_chunk，
    # 同时在外部控制好chunk的生成速度和发送间隔。