Recherche avancée

Sur d’autres sites (9264)

• A "region code" restriction for a custom created video dvd file [closed]

  17 décembre 2012, par user931392

  I want to create a video dvd ( no menus, just "plug and play" ) from a few video files. I`m doing it like this :

  ffmpeg -i sample-media/hellboy-2.wmv -y -target ntsc-dvd sample-media-to-mpeg/hellboy-2.vob
  
  
  
  dvdauthor -o sample-dvd -x dvdauthor-settings.xml
  
  
  
  mkisofs -dvd-video -o hellboy-2-trailers.iso sample-dvd/

  where "dvdauthor-settings.xml" is : link.

  But when I try to play the iso file in windows it says :

  Windows Media Player cannot play the DVD because the disc prohibits playback in your region of the world. You must obtain a disc that is intended for your geographic region.

  When I open the *.IFO file with IfoEdit it says that all world regions are unabled.

  Can someone tell me why is this happening ? ( maybe the whole process of creating the *.iso file is wrong ? )

• ffmpeg - Poll folder for files, and stream as video with rtp

  17 janvier 2019, par Omer

  (I’m a newbie when it comes to ffmpeg).
  I have an image source which saves files to a given folder in a rate of 30 fps. I want to wait for every (let’s say) 30 frames chunk, encode it to h264 and stream it with RDP to some other app.

  I thought about writing a python app which just waits for the images, and then executes an ffmpeg command. For that I wrote the following code :

  main.py :

  import os
  
  import Helpers
  
  import argparse
  
  import IniParser
  
  import subprocess
  
  from functools import partial
  
  
  
  from Queue import Queue
  
  from threading import Semaphore, Thread
  
  
  
  
  
  def Run(config):
  
  
  
      os.chdir(config.Workdir)
  
      iteration = 1
  
  
  
      q = Queue()
  
      Thread(target=RunProcesses, args=(q, config.AllowedParallelRuns)).start()
  
  
  
      while True:
  
  
  
          Helpers.FileCount(config.FramesPathPattern, config.ChunkSize * iteration)
  
  
  
          command = config.FfmpegCommand.format(startNumber = (iteration-1)*config.ChunkSize, vFrames=config.ChunkSize)
  
  
  
          runFunction = partial(subprocess.Popen, command)
  
          q.put(runFunction)
  
  
  
          iteration += 1
  
  
  
  def RunProcesses(queue, semaphoreSize):
  
  
  
      semaphore = Semaphore(semaphoreSize)
  
  
  
      while True:
  
  
  
          runFunction = queue.get()
  
  
  
          Thread(target=HandleProcess, args=(runFunction, semaphore)).start()
  
  
  
  def HandleProcess(runFunction, semaphore):
  
  
  
      semaphore.acquire()
  
  
  
      p = runFunction()
  
      p.wait()
  
  
  
      semaphore.release()
  
  
  
  if __name__ == '__main__':
  
  
  
      argparser = argparse.ArgumentParser()
  
      argparser.add_argument("config", type=str, help="Path for the config file")
  
      args = argparser.parse_args()
  
  
  
      iniFilePath = args.config
  
  
  
      config = IniParser.Parse(iniFilePath)
  
  
  
      Run(config)

  Helpers.py (not really relevant) :

  import os
  
  import time
  
  from glob import glob
  
  
  
  def FileCount(pattern, count):
  
  
  
      count = int(count)
  
  
  
      lastCount = 0
  
      while True:
  
  
  
          currentCount = glob(pattern)
  
  
  
          if lastCount != currentCount:
  
              lastCount = currentCount
  
  
  
          if len(currentCount) >= count and all([CheckIfClosed(f) for f in currentCount]):
  
  
  
              break
  
  
  
          time.sleep(0.05)
  
  
  
  def CheckIfClosed(filePath):
  
  
  
      try:
  
          os.rename(filePath, filePath)
  
          return True
  
      except:
  
          return False

  I used the following config file :

  Workdir = "C:\Developer\MyProjects\Streaming\OutputStream\PPM"
  
  ; Workdir is the directory of reference from which all paths are relative to.
  
  ; You may still use full paths if you wish.
  
  
  
  FramesPathPattern = "F*.ppm"
  
  ; The path pattern (wildcards allowed) where the rendered images are stored to.
  
  ; We use this pattern to detect how many rendered images are available for streaming.
  
  ; When a chunk of frames is ready - we stream it (or store to disk).
  
  
  
  ChunkSize = 30 ; Number of frames for bulk.
  
  ; ChunkSize sets the number of frames we need to wait for, in order to execute the ffmpeg command.
  
  ; If the folder already contains several chunks, it will first process the first chunk, then second, and so on...
  
  
  
  AllowedParallelRuns = 1 ; Number of parallel allowed processes of ffmpeg.
  
  ; This sets how many parallel ffmpeg processes are allowed.
  
  ; If more than one chunk is available in the folder for processing, we will execute several ffmpeg processes in parallel.
  
  ; Only when on of the processes will finish, we will allow another process execution.
  
  
  
  FfmpegCommand = "ffmpeg -re -r 30 -start_number {startNumber} -i F%08d.ppm -vframes {vFrames} -vf vflip -f rtp rtp://127.0.0.1:1234" ; Command to execute when a bulk is ready for streaming.
  
  ; Once a chunk is ready for processing, this is the command that will be executed (same as running it from the terminal).
  
  ; There is however a minor difference. Since every chunk starts with a different frame number, you can use the
  
  ; expression of "{startNumber}" which will automatically takes the value of the matching start frame number.
  
  ; You can also use "{vFrames}" as an expression for the ChunkSize which was set above in the "ChunkSize" entry.

  Please note that if I set "AllowedParallelRuns = 2" then it allows multiple ffmpeg processes to run simultaneously.

  I then tried to play it with ffplay and see if I’m doing it right.
  The first chunk was streamed fine. The following chunks weren’t so great. I got a lot of [sdp @ 0000006de33c9180] RTP: dropping old packet received too late messages.

  What should I do so I get the ffplay, to play it in the order of the incoming images ? Is it right to run parallel ffmpeg processes ? Is there a better solution to my problem ?

  Thank you !

• ffmpeg not reading stdin fast enough

  5 mars 2019, par Joshua Walsh

  I have a NodeJS program which launches ffmpeg (with child_process) and then provides realtime video data via stdin, using the pipe protocol.

  ffmpeg -nostdin -i pipe:0 -codec libx264 -preset veryfast -tune zerolatency -acodec aac -b:a 128k output/index.m3u8

  ffmpeg transcodes the video into h264 and muxes it into an HLS live stream.

  The issue that I have is that sometimes ffmpeg refuses to accept more input. The default behaviour of NodeJS is to buffer input until the child process can accept it, but after a while this causes my application to run out of memory.

  I tried a naive solution where if ffmpeg wasn’t able to read the input (if proc.stdin.write returns false) I would start discarding data until the drain event was raised on the stream, but this unsurprisingly led to badly degraded video output, with terrible artifacting.

  The nature of the source of the data makes it impossible for me to block, my application has to deal with it in realtime.

  ffmpeg is using only a fraction of the available resources on the system (35% CPU, 1% disk), so I’m not sure why it’s blocking stdin. If I specify a more demanding preset then it happily uses more CPU, so CPU speed shouldn’t be a limiting factor.

  Does anyone know why ffmpeg would be blocking stdin ? Is there a way I can tell ffmpeg to drop frames if it starts falling behind ?