Recherche avancée

Sur d’autres sites (11496)

• Definitive join MP3's in ffmpeg or avconv - whats the magic line of code ?

  10 février 2016, par pperrin

  I have some MP3’s they need to be concatenated in to a single MP3.

  What is the command line I need for FFMPEG or AVCONV to do this ?

  I don’t know or care about the quality/bit-rate etc of the inputs, I have what I have and they are random.

  I have hunted far and wide and found loads of people who like to talk about pages of useless detail that makes absolutely no difference to me...

  So...

  I have been using :

  ffmpeg -i "concat:file1.mp3|file2.mp3" -b:a:320000 -acodec file3.mp3

  The output sounds fine, but the output file often shows the duration and bitrate wrong on the output... what is the magic line of code I seek ?

  I am in no hurry - and can run the files through a dozen other processes if needed, and if quality goes down I really really don’t care - I just want a fully functional MP3 at the end of it.

• Joining realtime raw PCM streams with ffmpeg and streaming them back out

  15 avril 2024, par Nathan Ladwig

  I am trying to use ffmpeg to join two PCM streams. I have it sorta kinda working but it's not working great.

  


  I am using Python to receive two streams from two computers running Scream Audio Driver ( ttps ://github.com/duncanthrax/scream )

  


  I am taking them in over UDP and writing them to pipes. The pipes are being received by ffmpeg and mixed, it's writing the mixed stream to another pipe. I'm reading that back in Python and sending it to the target receiver.

  


  My ffmpeg command is

  


  ['ffmpeg', 
'-use_wallclock_as_timestamps', 'true', '-f', 's24le', '-ac', '2', '-ar', '48000', '-i', '/tmp/ffmpeg-fifo-1',
'-use_wallclock_as_timestamps', 'true', '-f', 's24le', '-ac', '2', '-ar', '48000', '-i', '/tmp/ffmpeg-fifo-2',
'-filter_complex', '[0]aresample=async=1[a0],[1]aresample=async=1[a1],[a0][a1]amix', '-y',
'-f', 's24le', '-ac', '2', '-ar', '48000', '/tmp/ffmpeg-fifo-in']


  


  My main issue is that it should be reading ffmpeg-fifo-1 and ffmpeg-fifo-2 asynchronously, but it appears to be not. When the buffers get more than 50 frames out of sync with each other ffmpeg hangs and doesn't recover. I would like to fix this.

  


  In this hacky test code the number of frames sent over each stream are counted and empty frames are sent if the count hits 12. This keeps ffmpeg happy.

  


  The code below takes in two 48KHz 24-bit stereo PCM streams with Scream's header, mixes them, applies the same header, and sends them back out.

  


  It works most of the time. Sometimes I'm getting blasted with static, I think this is when only one or two bytes of a frame are making it to ffmpeg, and it loses track.

  


  The header is always 1152 bytes of pcm data with a 5 byte header. It's described in the Scream repo readme

  


  This is my header :

  


  01 18 02 03 00

  


  01 - 48KHz
18 - Sampling Rate (18h=24d, 24bit)
02 - 2 channels
03 00 - WAVEFORMATEXTENSIBLE

  


  import socket
import struct
import threading
import os
import sys
import time
import subprocess
import tempfile
import select

class Sender(threading.Thread):
    def __init__(self):
        super().__init__()
        TEMPDIR = tempfile.gettempdir() + "/"
        self.fifoin = TEMPDIR + "ffmpeg-fifo-in"
        self.start()

    def run(self):
        self.fd = open(self.fifoin, "rb")
        self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        while True:
            try:
                header = bytes([0x01, 0x18, 0x02, 0x03, 0x00])  # 48khz, 24-bit, stereo
                data = self.fd.read(1152)
                sendbuf = header + data
                self.sock.sendto(sendbuf, ("192.168.3.199", 4010))  # Audio sink
            except Exception as e:
                print("Except")
                print(e)

class Receiver(threading.Thread):
    def __init__(self):
        super().__init__()
        TEMPDIR = tempfile.gettempdir() + "/"
        self.fifo1 = TEMPDIR + "ffmpeg-fifo-1"
        self.fifo2 = TEMPDIR + "ffmpeg-fifo-2"
        self.fifoin = TEMPDIR + "ffmpeg-fifo-in"
        self.fifos = [self.fifo1, self.fifo2]
        try:
            try:
                os.remove(self.fifoin)
            except:
                pass
            os.mkfifo(self.fifoin)
        except:
            pass
        self.start()
        sender=Sender()

    def run(self):
        ffmpeg_command=['ffmpeg', '-use_wallclock_as_timestamps', 'true', '-f', 's24le', '-ac', '2', '-ar', '48000', '-i', self.fifo1,
                                  '-use_wallclock_as_timestamps', 'true', '-f', 's24le', '-ac', '2', '-ar', '48000', '-i', self.fifo2,
                                  '-filter_complex', '[0]aresample=async=1[a0],[1]aresample=async=1[a1],[a0][a1]amix', "-y", '-f', 's24le', '-ac', '2', '-ar', '48000', self.fifoin]
        print(ffmpeg_command)

        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
        sock.setsockopt(socket.SOL_SOCKET,socket.SO_RCVBUF,4096)
        sock.bind(("", 16401))

        recvbuf = bytearray(1157)
        framecount = [0,0]
        closed = 1
        while True:
            ready = select.select([sock], [], [], .2)
            if ready[0]:
                recvbuf, addr = sock.recvfrom(1157)
                if closed == 1:
                    for fifo in self.fifos:
                        try:
                            try:
                                os.remove(fifo)
                            except:
                                pass
                            os.mkfifo(fifo)
                        except:
                            pass
                    framecount = [0,0]
                    print("data, starting ffmpeg")
                    ffmpeg = subprocess.Popen (ffmpeg_command, shell=False, stdout=subprocess.PIPE, stdin=subprocess.PIPE)
                    fifo1_fd = os.open(self.fifo1, os.O_RDWR)
                    fifo1_file = os.fdopen(fifo1_fd, 'wb', 0)
                    fifo2_fd = os.open(self.fifo2, os.O_RDWR)
                    fifo2_file = os.fdopen(fifo2_fd, 'wb', 0)
                    closed = 0
                    for i in range(0,6):
                        fifo1_file.write(bytes([0]*1157))
                        fifo2_file.write(bytes([0]*1157))

                if addr[0] == "192.168.3.199":
                    fifo1_file.write(recvbuf[5:])
                    framecount[0] = framecount[0] + 1

                if addr[0] == "192.168.3.119":
                    fifo2_file.write(recvbuf[5:])
                    framecount[1] = framecount[1] + 1

                # Keep buffers roughly in sync while playing
                targetframes=max(framecount)
                if targetframes - framecount[0] > 11:
                    while (targetframes - framecount[0]) > 0:
                        fifo1_file.write(bytes([0]*1157))
                        framecount[0] = framecount[0] + 1

                if targetframes - framecount[1] > 11:
                    while (targetframes - framecount[1]) > 0:
                        fifo2_file.write(bytes([0]*1157))
                        framecount[1] = framecount[1] + 1
            else:
                if closed == 0:
                    ffmpeg.kill()
                    print("No data, killing ffmpeg")
                    fifo1_file.close()
                    fifo2_file.close()
                    closed = 1
receiver=Receiver()

while True:
    time.sleep(50000)


  


  Does anybody have any pointers on how I can make this better ?

  


• aarch64 : hevc : Specialize put_hevc_\type\()_h*_8_neon for horizontal looping

  24 mars 2024, par Martin Storsjö

  aarch64 : hevc : Specialize put_hevc_\type\()_h*_8_neon for horizontal looping
  For widths of 32 pixels and more, loop first horizontally,
  
  then vertically.
  Previously, this function would process a 16 pixel wide slice
  
  of the block, looping vertically. After processing the whole
  
  height, it would backtrack and process the next 16 pixel wide
  
  slice.
  When doing 8tap filtering horizontally, the function must load
  
  7 more pixels (in practice, 8) following the actual inputs, and
  
  this was done for each slice.
  By iterating first horizontally throughout each line, then
  
  vertically, we access data in a more cache friendly order, and
  
  we don't need to reload data unnecessarily.
  Keep the original order in put_hevc_\type\()_h12_8_neon ; the
  
  only suboptimal case there is for width=24. But specializing
  
  an optimal variant for that would require more code, which
  
  might not be worth it.
  For the h16 case, this implementation would give a slowdown,
  
  as it now loads the first 8 pixels separately from the rest, but
  
  for larger widths, it is a gain. Therefore, keep the h16 case
  
  as it was (but remove the outer loop), and create a new specialized
  
  version for horizontal looping with 16 pixels at a time.
  Before :                  Cortex A53      A72      A73  Graviton 3
  
  put_hevc_qpel_h16_8_neon :     710.5    667.7    692.5   211.0
  
  put_hevc_qpel_h32_8_neon :    2791.5   2643.5   2732.0   883.5
  
  put_hevc_qpel_h64_8_neon :   10954.0  10657.0  10874.2  3241.5
  
  After :
  
  put_hevc_qpel_h16_8_neon :     697.5    663.5    705.7   212.5
  
  put_hevc_qpel_h32_8_neon :    2767.2   2684.5   2791.2   920.5
  
  put_hevc_qpel_h64_8_neon :   10559.2  10471.5  10932.2  3051.7
  Signed-off-by : Martin Storsjö <martin@martin.st>
  

  • [DH] libavcodec/aarch64/hevcdsp_init_aarch64.c
  • [DH] libavcodec/aarch64/hevcdsp_qpel_neon.S