Recherche avancée

Sur d’autres sites (1646)

• Python ThreadedTCPServer : "Name or service not known"

  11 avril 2014, par Hal

  I was developing a ThreadedTCPServer to communicate with a PHP application also residing in this same machine. This is suppose to receive requests from this PHP app and to convert some videos locally using ffmpeg.

  Here's the code :

  # -*- coding: utf-8 -*- 
  
  import os
  
  import socket
  
  import threading
  
  import logging.config
  
  import SocketServer, time
  
  from queuev2 import QueueServer
  
  
  
  logging.basicConfig(format='[%(asctime)s.%(msecs).03d] %(message)s', datefmt='%Y-%m-%d %H:%M:%S', filename=os.path.join(os.path.dirname(os.path.realpath(__file__)), 'converter.log'), level=logging.INFO)
  
  
  
  class ThreadedTCPRequestHandler(SocketServer.BaseRequestHandler):
  
  
  
      def handle(self):
  
          data = self.request.recv(1024)
  
          cur_thread = threading.current_thread()
  
          response = "{}: {}".format(cur_thread.name, data)
  
          videoPool.add(data)
  
          print "Output! %s" % data
  
          self.request.sendall(response)
  
  
  
  class ThreadedTCPServer(SocketServer.ThreadingMixIn, SocketServer.TCPServer):
  
      pass
  
  
  
  if __name__ == "__main__":
  
  
  
      logging.info("Initializing...")
  
      videoPool = QueueServer()
  
      HOST, PORT = "localhost", 6666
  
  
  
      server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
  
      ip, port = server.server_address
  
  
  
      # Start a thread with the server -- that thread will then start one
  
      # more thread for each request
  
      server_thread = threading.Thread(target=server.serve_forever)
  
  
  
      # Exit the server thread when the main thread terminates
  
      server_thread.daemon = True
  
      server_thread.start()
  
  
  
      print("Server loop running in thread: %s" % server_thread.name)
  
  
  
      # "Groundhog day" time
  
      while True:
  
          time.sleep(999)
  
          pass
  
  
  
      #server.shutdown()

  This works well in my development laptop, but on the server i'm getting the following error :

  Traceback (most recent call last):
  
    File "server.py", line 31, in <module>
  
      server = ThreadedTCPServer((HOST, PORT), ThreadedTCPRequestHandler)
  
    File "/usr/lib/python2.7/SocketServer.py", line 408, in __init__
  
      self.server_bind()
  
    File "/usr/lib/python2.7/SocketServer.py", line 419, in server_bind
  
      self.socket.bind(self.server_address)
  
    File "/usr/lib/python2.7/socket.py", line 224, in meth
  
      return getattr(self._sock,name)(*args)
  
  socket.gaierror: [Errno -2] Name or service not known
  
  </module>

  I'm guessing it has to do with the port I'm using (6666), but I've tried others and it hasn't been working. Would Unix Domain Sockets be of use here ? Can you give me an example ?

• lavu/x86 : add FFT assembly

  10 avril 2021, par Lynne

  lavu/x86 : add FFT assembly
  This commit adds a pure x86 assembly SIMD version of the FFT in libavutil/tx.
  
  The design of this pure assembly FFT is pretty unconventional.
  On the lowest level, instead of splitting the complex numbers into
  
  real and imaginary parts, we keep complex numbers together but split
  
  them in terms of parity. This saves a number of shuffles in each transform,
  
  but more importantly, it splits each transform into two independent
  
  paths, which we process using separate registers in parallel.
  
  This allows us to keep all units saturated and lets us use all available
  
  registers to avoid dependencies.
  
  Moreover, it allows us to double the granularity of our per-load permutation,
  
  skipping many expensive lookups and allowing us to use just 4 loads per register,
  
  rather than 8, or in case FMA3 (and by extension, AVX2), use the vgatherdpd
  
  instruction, which is at least as fast as 4 separate loads on old hardware,
  
  and quite a bit faster on modern CPUs).
  Higher up, we go for a bottom-up construction of large transforms, foregoing
  
  the traditional per-transform call-return recursion chains. Instead, we always
  
  start at the bottom-most basis transform (in this case, a 32-point transform),
  
  and continue constructing larger and larger transforms until we return to the
  
  top-most transform.
  
  This way, we only touch the stack 3 times per a complete target transform :
  
  once for the 1/2 length transform and two times for the 1/4 length transform.
  The combination algorithm we use is a standard Split-Radix algorithm,
  
  as used in our C code. Although a version with less operations exists
  
  (Steven G. Johnson and Matteo Frigo's "A modified split-radix FFT with fewer
  
  arithmetic operations", IEEE Trans. Signal Process. 55 (1), 111–119 (2007),
  
  which is the one FFTW uses), it only has 2% less operations and requires at least 4x
  
  the binary code (due to it needing 4 different paths to do a single transform).
  
  That version also has other issues which prevent it from being implemented
  
  with SIMD code as efficiently, which makes it lose the marginal gains it offered,
  
  and cannot be performed bottom-up, requiring many recursive call-return chains,
  
  whose overhead adds up.
  We go through a lot of effort to minimize load/stores by keeping as much in
  
  registers in between construcring transforms. This saves us around 32 cycles,
  
  on paper, but in reality a lot more due to load/store aliasing (a load from a
  
  memory location cannot be issued while there's a store pending, and there are
  
  only so many (2 for Zen 3) load/store units in a CPU).
  
  Also, we interleave coefficients during the last stage to save on a store+load
  
  per register.
  Each of the smallest, basis transforms (4, 8 and 16-point in our case)
  
  has been extremely optimized. Our 8-point transform is barely 20 instructions
  
  in total, beating our old implementation 8-point transform by 1 instruction.
  
  Our 2x8-point transform is 23 instructions, beating our old implementation by
  
  6 instruction and needing 50% less cycles. Our 16-point transform's combination
  
  code takes slightly more instructions than our old implementation, but makes up
  
  for it by requiring a lot less arithmetic operations.
  Overall, the transform was optimized for the timings of Zen 3, which at the
  
  time of writing has the most IPC from all documented CPUs. Shuffles were
  
  preferred over arithmetic operations due to their 1/0.5 latency/throughput.
  On average, this code is 30% faster than our old libavcodec implementation.
  
  It's able to trade blows with the previously-untouchable FFTW on small transforms,
  
  and due to its tiny size and better prediction, outdoes FFTW on larger transforms
  
  by 11% on the largest currently supported size.
  

  • [DH] libavutil/tx.c
  • [DH] libavutil/tx_priv.h
  • [DH] libavutil/x86/Makefile
  • [DH] libavutil/x86/tx_float.asm
  • [DH] libavutil/x86/tx_float_init.c

• How can I record audio along with Aforge player video recording ?

  4 juin 2019, par H.NS

  My app is playing webcam video using Aforge Plyer. Now I want to record this video. Using Aforge player audio recording is not possible.

  Is there any way to record audio separately and merge it with recorded video using Aforge player ?

  Found that using Direct Show architecture is the way to achieve this. But it will be very difficult to change the architecture at the last time of development. Since I’m unaware with directshow concepts and almost 90 percentage of my project is completed with Aforge player.

  My current code is here. It can record video from selected webcam using aforge player. But audio is missing

  using AForge.Video;
  
  using AForge.Video.DirectShow;
  
  using Accord.Video.FFMPEG;
  
  
  
      private FilterInfoCollection VideoCaptureDevices;
  
      private VideoCaptureDevice FinalVideo = null;
  
      private VideoCaptureDeviceForm captureDevice;
  
      private Bitmap video;
  
      private VideoFileWriter FileWriter = new VideoFileWriter();
  
      private SaveFileDialog saveAvi;
  
  
  
      private void VideoRecord_Load(object sender, EventArgs e)
  
      {
  
          VideoCaptureDevices = new FilterInfoCollection(FilterCategory.VideoInputDevice);
  
          captureDevice = new VideoCaptureDeviceForm();
  
      }
  
      private void play_Click(object sender, EventArgs e)
  
      {
  
          if (captureDevice.ShowDialog(this) == DialogResult.OK)
  
          {
  
              VideoCaptureDevice videoSource = captureDevice.VideoDevice;
  
              FinalVideo = captureDevice.VideoDevice;
  
              FinalVideo.NewFrame += new NewFrameEventHandler(FinalVideo_NewFrame);
  
              FinalVideo.Start();
  
          }
  
      }
  
      void FinalVideo_NewFrame(object sender, NewFrameEventArgs eventArgs)
  
      {
  
          if (butStop.Text == "Stop Record")
  
          {
  
              video = (Bitmap)eventArgs.Frame.Clone();
  
              FileWriter.WriteVideoFrame(video);
  
          }
  
          else
  
          {
  
              video = (Bitmap)eventArgs.Frame.Clone();;
  
          }
  
      }
  
      private void Record_Click(object sender, EventArgs e)
  
      {
  
          saveAvi = new SaveFileDialog();
  
          saveAvi.Filter = "Avi Files (*.avi)|*.avi";
  
          if (saveAvi.ShowDialog() == System.Windows.Forms.DialogResult.OK)
  
          {
  
              int h = captureDevice.VideoDevice.VideoResolution.FrameSize.Height;
  
              int w = captureDevice.VideoDevice.VideoResolution.FrameSize.Width;
  
              FileWriter.Open(saveAvi.FileName, w, h, 25, VideoCodec.Default, 5000000);
  
              FileWriter.WriteVideoFrame(video);
  
              butStop.Text = "Stop Record";
  
          }
  
      }
  
      private void stopRecord_Click(object sender, EventArgs e)
  
      {
  
          if (butStop.Text == "Stop Record")
  
          {
  
              butStop.Text = "Stop";
  
              if (FinalVideo == null)
  
              { return; }
  
              if (FinalVideo.IsRunning)
  
              {
  
                  FileWriter.Close();
  
              }
  
          }
  
          else
  
          {
  
              this.FinalVideo.Stop();
  
              FileWriter.Close();
  
          }
  
      }
  
  }
  
  }