@dong-zeyu yes, you have to calculate pts / dts yourself. Something like below worked for me:
import av
avin = av.open("test.264", "r", "h264")
avout = av.open("test.mp4", "w", format="mp4")
avout.add_stream(template=avin.streams[0])
time_base = int(1 / avin.streams[0].time_base)
rate = avin.streams[0].base_rate
ts_inc = int(time_base / rate)
ts = 0
for pkt in avin.demux():
pkt.pts = ts
pkt.dts = ts
avout.mux(pkt)
ts += ts_inc
avin.close()
avout.close()
@nitanmarcel could you share what exactly are you trying to open? which URL etc. Basically, code snippet that doesn't work
And about the snippet I removed it but I haven't set an out file instead I've tried to read it frame by frame
The library I want to use pyav is called tgcalls and here's an example on how it should be used https://github.com/MarshalX/tgcalls/blob/main/examples/restream_using_raw_data.py
The library I want to use pyav is called tgcalls and here's an example on how it should be used https://github.com/MarshalX/tgcalls/blob/main/examples/restream_using_raw_data.py
@nitanmarcel the ffmpeg cli may work in that case
And this is how I'm currently using the ffmpeg-python https://github.com/nitanmarcel/tl_radio/blob/3edb840fe926f8d762eecf9a5fd7203475527006/tl_radio/player/_stream.py#L42
@quantotto no need to replace 224.0.0.1 which is a multicast address and should work fine on most situations for udp
if slow down the testsrc rate, then the
should consider other languages maybe I guess?
if slow down the testsrc rate, then the
while loop is also be slowed down. so it can also help solve this issue if it's really because the Python is slow.should consider other languages maybe I guess?
but if you want to read frame by frame, I guess you should caution overflow of ffmpeg libs(PYAV depends) internal's buffer
and change src rate from 30 to 2 solving the issue may also indicate the reason?
will try to change it to 60 fps later.
@nitanmarcel the following works fine for me and not reaching end of file. It continuously reads packets from the stream. I had to stop it with CTRL-C; otherwise, it runs endlessly.
>>> import av
>>> a = av.open("https://stream.live.vc.bbcmedia.co.uk/bbc_radio_one")
>>> s = a.streams.audio[0]
>>> s
<av.AudioStream #0 mp3float at 48000Hz, stereo, fltp at 0x1c4ce7a9940>
>>> for pkt in a.demux(s):
... print(pkt.pts)
...
0
338688
677376
1016064
1354752
1693440
2032128
2370816
2709504
...async def _start_av(self):
input_ = await run_in_executor(av.open, self.url, options={"format": "s16le", "acodec": "pcm_s16le", "ac": "2", "ar": "48k"})
for frame in input_.decode():
if frame:
self._fifo.write(frame)
wait
So I've started with something like this:
self._fifo = av.AudioFifo(format="s16le")
def _start_av(self):
input_ = av.open(self.url, options={"format": "s16le", "acodec": "pcm_s16le", "ac": "2", "ar": "48k"})
for frame in input_decode():
if frame:
self._fifo.write(frame)
def read(self, length):
data = self._fifo.read(length)
if data:
data = data.to_ndarray().tobytes()
return data # returns the data to the libraryBut I have a small problem, the data received from the AudioFifo is bigger than the one requested
or wait, maybe I'm getting the AudioFifo wrong
The read function is called every time by the library when a set of bytes are played
And what I'm looking for is to use pyav to format any audio from an url (it can also be an ytdl url) to the required format and feed it to the library and all of this while keeping the memory clean.
@nitanmarcel I read about AudioFifo in docs and it could be that you use length incorrectly.
AudioFifo.read method expects number of samples to read. You mentioned that the library supplying length expects length amount of bytes. With Audio, amount of samples is not equal to amount of bytes. For example, in your case, pcm_s16le means that each sample is 16 bit little endian and this is 2 bytes per sample. If library is indeed supplying to you number of bytes it expects, you need to read length / 2 number of samples. With that, I hope the library is aligned with audio realities and asks for number of samples.
Also is the conversion right? Because I just did length / 8 (8 being the bytes/sample) and even tho the length of bytes was correct the sound came distorted with white noises (hints to a bad number of bytes or bad format)
~~~async def main():
async with client:
async with client:
fifo: av.AudioFifo = av.AudioFifo(format="s16le")
resampler: av.AudioResampler = av.AudioResampler(
format="s16", layout="stereo", rate=48000)
def on_played_data(_, length):
data = fifo.read(length / 4)
if data:
data = data.to_ndarray().tobytes()
return data
group_call_factory = GroupCallFactory(client, CLIENT_TYPE)
group_call = group_call_factory.get_raw_group_call(
on_played_data=on_played_data)
await group_call.start(PEER)
while not group_call.is_connected:
await asyncio.sleep(1)
input_ = av.open(STREAM)
for frame in input_.decode():
if frame:
print(frame)
frame = resampler.resample(frame)
fifo.write(frame)
await client.run_until_disconnected()~~~
This is the working code for me
Because if not I might need to create my own implementation