how to group_call_raw change music?

[hdcola]

I saw this new example and it felt great!

#126

I would like to ask how to switch a new music?

[hdcola]

this is work!

import asyncio
from asyncio.tasks import sleep
import os
from pytgcalls import GroupCallFactory
import pyrogram
import av
from config import Config

API_HASH = Config.API_HASH
API_ID = Config.API_ID

CHAT_PEER = Config.CHAT  # chat or channel where you want to play audio
SOURCE1 = "downloads/one.m4a"
SOURCE2 = "downloads/GoodTimes.m4a" # Audio file path or stream url: eg. https://file-examples-com.github.io/uploads/2017/11/file_example_MP3_700KB.mp3
SOURCE3 = "downloads/music.m4a"
CLIENT_TYPE = GroupCallFactory.MTPROTO_CLIENT_TYPE.PYROGRAM
# for Telethon uncomment line below
# CLIENT_TYPE = pytgcalls.GroupCallFactory.MTPROTO_CLIENT_TYPE.TELETHON

# fifo = av.AudioFifo(format="s16le")
fifo = av.AudioFifo()
resampler = av.AudioResampler(format="s16", layout="stereo", rate=48000)


def on_played_data(gc, length):
    data = None
    if fifo :
        data = fifo.read(length / 4)
        if data:
            data = data.to_ndarray().tobytes()
    return data


async def main(client):
    global fifo,resampler
    await client.start()
    while not client.is_connected:
        await asyncio.sleep(1)

    group_call_factory = GroupCallFactory(client, CLIENT_TYPE)
    group_call_raw = group_call_factory.get_raw_group_call(on_played_data=on_played_data)
    await group_call_raw.start(CHAT_PEER)
    while not group_call_raw.is_connected:
        await asyncio.sleep(1)

    # group_call_raw.pause_playout()

    print(f"decode {SOURCE1}")
    _input = av.open(SOURCE1)
    for frame in _input.decode():
        if frame:
            frame.pts = None
            frame = resampler.resample(frame)
            fifo.write(frame)

    await sleep(3)

    print(f"decode {SOURCE2}")
    fifo = av.AudioFifo()
    resampler = av.AudioResampler(format="s16", layout="stereo", rate=48000)


    _input = av.open(SOURCE2)
    for frame in _input.decode():
        if frame:
            frame.pts = None
            frame = resampler.resample(frame)
            fifo.write(frame)
    
    await pyrogram.idle()

if __name__ == "__main__":
    pyro_client = pyrogram.Client(
        Config.SESSION,
        api_hash=os.environ.get('API_HASH', API_HASH),
        api_id=os.environ.get('API_ID', API_ID)
    )

    loop = asyncio.get_event_loop()
    loop.run_until_complete(main(pyro_client))

[MarshalX]

Using group call row with working via bytes required more programming skills that group call file. So it is for more advanced programmers

[nitanmarcel]

Nah it doesn't need advanced programing. It requires a little bit of logic.

The logic is explained below by me :)

[nitanmarcel]

Yes. There are 2 hints that the audio playback has ended:

1. The for loop reading the frame has ended. Happens when the stream reaches the end.
2. on_played_data doesn't return any bytes (eg. data is None).

Checking these two will gives you the feedback if the stream has ended or not.

[hdcola]

Wrong. Keep the format to make sure the output is the correct one

Do you have any good ideas for switching to a new song if it hasn't finished playing?

[nitanmarcel]

Wrong. Keep the format to make sure the output is the correct one

Do you have any good ideas for switching to a new song if it hasn't finished playing?

You end break the for loop

[nitanmarcel]

And close the input _input.close() which I forgot to add

[hdcola]

And close the input _input.close() which I forgot to add

I tried running it on my mac and found that the _input.decode for actually ran out very quickly.

[nitanmarcel]

And close the input _input.close() which I forgot to add

I tried running it on my mac and found that the _input.decode for actually ran out very quickly.

And are you sure that the library didn't successfully resampled the audio?

[hdcola]

These two classes take into account the buffer size and the _input that should be closed on exit

class AudioFifo(av.AudioFifo):
    def __init__(self, BufferLimit: int = 5, *args, **kwargs):
        super().__init__(*args, **kwargs)

        self.AUDIOBUFFERLIMITMS = BufferLimit * 50 * 960

        self.haveToFillBuffer = False

    def read(self, samples: int = 960) -> bytes:

        AudioFrame = super().read(samples)
        if not AudioFrame:
            return None

        if self.samples < self.AUDIOBUFFERLIMITMS:
            self.haveToFillBuffer = False
        else:
            self.haveToFillBuffer = True

        return AudioFrame

    def write(self, *args, **kwargs):
        super().write(*args, **kwargs)
        if self.samples < self.AUDIOBUFFERLIMITMS:
            self.haveToFillBuffer = False
        else:
            self.haveToFillBuffer = True

    def reset(self):
        super().read(samples=max(self.samples - 960, 0), partial=True)

class AudioFileFifo():
    file = None
    result = None
    fifo = None
    resampler = None

    def __init__(self):
        self.fifo = AudioFifo()
        self.resampler = av.AudioResampler(format="s16", layout="stereo", rate=48000)

    def on_played_data(self,gc, length):
        data = None
        if self.fifo:
            data = self.fifo.read(length / 4)
            if data:
                data = data.to_ndarray().tobytes()
        return data

    async def avdecode(self, file):
        self.file = file
        self.fifo = AudioFifo()
        self.resampler = av.AudioResampler(format="s16", layout="stereo", rate=48000)
        await self._av_decode()

    async def _av_decode(self):
        self._input = av.open(self.file)
        for frame in self._input.decode():
            if frame:
                frame.pts = None
                frame = self.resampler.resample(frame)
                try:
                    while self.fifo.haveToFillBuffer:
                        await asyncio.sleep(0.01)
                except asyncio.CancelledError:
                    self._input.close()
                    self.fifo.reset()
                    raise
                self.fifo.write(frame)
        self._input.close()

[nitanmarcel]

Nah, there's no need to create another class, it also makes the code look bad since you can resolve the problem using 2 variables:

is_resampling = False
is_done = True # True because there's nothing started yet

Then when resampling the file:

_input = av.open(SOURCE1)
is_resampling = True
for frame in _input.decode():
    if frame:
        frame.pts = None
        frame = resampler.resample(frame)
        fifo.write(frame)
is_resampling = False

And in read buffer:

def on_played_data(gc, length):
    data = None
    if fifo :
        data = fifo.read(length / 4)
        if data:
            data = data.to_ndarray().tobytes()
        is_done = not is_downloading and data is None
            
    return data

[nitanmarcel]

Also to reset (clear) the FIFO just call read() with no arguments. It will read all the samples:

https://pyav.org/docs/stable/api/audio.html?highlight=audiofifo#av.audio.fifo.AudioFifo.read

[nitanmarcel]

Stop Writing Classes