Recherche avancée

Sur d’autres sites (13121)

• FFmpeg playable MP4 segmented video from RTSP

  5 février 2021, par Michael Novotný

  I have problem with creating playable uncomplete MP4 file created from FFMPEG. In my case I have some infinite RTSP stream (h.264) from IP camera.
My target is record this stream to MP4 files for playback. If i use FFMPEG mp4 muxer, work correctly.

  


  /usr/bin/ffmpeg -progress pipe:5 -use_wallclock_as_timestamps 1 -analyzeduration 10000000 -probesize 10000000 -fflags +igndts -rtsp_transport tcp -hwaccel auto -loglevel warning -i rtsp://****:****@*******:****/ -y -an -vcodec copy -strict experimental -movflags frag_keyframe+empty_moov -f segment -segment_format mp4 -segment_format_options movflags=+faststart -segment_atclocktime 1 -reset_timestamps 1 -strftime 1 -segment_time 15 /Shinobi/videos/bWkwjTWdRt/Rm67cYyq50/test-%S.mp4


  


  FFMPEG will create one MP4 file which still increasing its size. If I try copy or simply open this (uncomplete, still increased ... of course :) ) file, it's correcly play. But it's still only one file ... still bigger and bigger. For long-term recording cam (few weeks) it's not good.
I want segment this stream to multiple smaller MP4 files (as you knows from another typical NVR systems). For example : segment for 30minutes.
I used "segment" muxer.

  


  /usr/bin/ffmpeg -progress pipe:5 -use_wallclock_as_timestamps 1 -analyzeduration 10000000 -probesize 10000000 -fflags +igndts -rtsp_transport tcp -hwaccel auto -loglevel warning -i rtsp://*****:****@*********:****/ -y -an -vcodec copy -strict -2 -movflags frag_keyframe+empty_moov -f mp4 -segment_atclocktime 1 -reset_timestamps 1 -strftime 1 -segment_list pipe:8 -segment_time 15 /Shinobi/videos/bWkwjTWdRt/Rm67cYyq50/test-%S.mp4


  


  It looks like work correctly. New file with defined mask is created every 30 minutes. If I try copy or simply open(and play) anyone "completed 30min segment file" it"s works correctly. Problem is with last file (more precisely : newest, still uncompleted last segment file) - it's not playable (moov atom not found).

  


  I Googled my problem many time with another keywords. I was try many my wonders. I readed FFMPEG documentation maybe 5times.

  


  Problem is with second passthroug which "segment muxer" do (which do -movflags +faststart .. for example). It's logicaly, second passthroug not be did in last(newest) file yet.

  


  Is there way to make it work ? If I want see time for 2-3 mins ago it's no possible wait up to 30minutes for "complete segment" ... and at the same time it is not possible to have a billion files with 2-3sec segments.
How did other NVR systems solve this ? Synology, Hikvision and more has in their file system recorded MP4 soubory which one of them is still uncompleted, still growing, but normaly PLAYABLE.

  


  A few last days I tried this with no success. I'am absolutely angry and sad. I hope that my text is understandable

  


  Thank you

  


  This options has no effect in my case (tried) :

  


  -movflags frag_keyframe+empty_moov

  


  -movflags faststart

  


  -movflags separate_moof

  


  -fragsize *** / -fragtime ***

  


  -strict -2 / -strict experimental

  


• Cortex-A7 instruction cycle timings

  15 mai 2014, par Mans — ARM

  The Cortex-A7 ARM core is a popular choice in low-power and low-cost designs. Unfortunately, the public TRM does not include instruction timing information. It does reveal that execution is in-order which makes measuring the throughput and latency for individual instructions relatively straight-forward.

  The table below lists the measured issue cycles (inverse throughput) and result latency of some commonly used instructions.

  It should be noted that in some cases, the perceived latency depends on the instruction consuming the result. Most of the values were measured with the result used as input to the same instruction. For instructions with multiple outputs, the latencies of the result registers may also differ.

  Finally, although instruction issue is in-order, completion is out of order, allowing independent instructions to issue and complete unimpeded while a multi-cycle instruction is executing in another unit. For example, a 3-cycle MUL instruction does not block ADD instructions following it in program order.

  ALU instructions	Issue cycles	Result latency
  MOV Rd, Rm	1/2	1
  ADD Rd, Rn, #imm	1/2	1
  ADD Rd, Rn, Rm	1	1
  ADD Rd, Rn, Rm, LSL #imm	1	1
  ADD Rd, Rn, Rm, LSL Rs	1	1
  LSL Rd, Rn, #imm	1	2
  LSL Rd, Rn, Rs	1	2
  QADD Rd, Rn, Rm	1	2
  QADD8 Rd, Rn, Rm	1	2
  QADD16 Rd, Rn, Rm	1	2
  CLZ Rd, Rm	1	1
  RBIT Rd, Rm	1	2
  REV Rd, Rm	1	2
  SBFX Rd, Rn	1	2
  BFC Rd, #lsb, #width	1	2
  BFI Rd, Rn, #lsb, #width	1	2
  NOTE : Shifted operands and shift amounts needed one cycle early.
  Multiply instructions	Issue cycles	Result latency
  MUL Rd, Rn, Rm	1	3
  MLA Rd, Rn, Rm, Ra	1	31
  SMULL Rd, RdHi, Rn, Rm	1	3
  SMLAL Rd, RdHi, Rn, Rm	1	31
  SMMUL Rd, Rn, Rm	1	3
  SMMLA Rd, Rn, Rm, Ra	1	31
  SMULBB Rd, Rn, Rm	1	3
  SMLABB Rd, Rn, Rm, Ra	1	31
  SMULWB Rd, Rn, Rm	1	3
  SMLAWB Rd, Rn, Rm, Ra	1	31
  SMUAD Rd, Rn, Rm	1	3
  1 Accumulator forwarding allows back to back MLA instructions without delay.
  Divide instructions	Issue cycles	Result latency
  SDIV Rd, Rn, Rm	4-20	6-22
  UDIV Rd, Rn, Rm	3-19	5-21
  Load/store instructions	Issue cycles	Result latency
  LDR Rt, [Rn]	1	3
  LDR Rt, [Rn, #imm]	1	3
  LDR Rt, [Rn, Rm]	1	3
  LDR Rt, [Rn, Rm, lsl #imm]	1	3
  LDRD Rt, Rt2, [Rn]	1	3-4
  LDM Rn, regs	1-8	3-10
  STR Rt, [Rn]	1	2
  STRD Rt, Rt2, [Rn]	1	2
  STM Rn, regs	1-10	2-12
  NOTE : Load results are forwarded to dependent stores without delay.
  VFP instructions	Issue cycles	Result latency
  VMOV.F32 Sd, Sm	1	4
  VMOV.F64 Dd, Dm	1	4
  VNEG.F32 Sd, Sm	1	4
  VNEG.F64 Dd, Dm	1	4
  VABS.F32 Sd, Sm	1	4
  VABS.F64 Dd, Dm	1	4
  VADD.F32 Sd, Sn, Sm	1	4
  VADD.F64 Dd, Dn, Dm	1	4
  VMUL.F32 Sd, Sn, Sm	1	4
  VMUL.F64 Dd, Dn, Dm	4	7
  VMLA.F32 Sd, Sn, Sm	1	81
  VMLA.F64 Dd, Dn, Dm	4	112
  VFMA.F32 Sd, Sn, Sm	1	81
  VFMA.F64 Dd, Dn, Dm	5	82
  VDIV.F32 Sd, Sn, Sm	15	18
  VDIV.F64 Dd, Dn, Dm	29	32
  VSQRT.F32 Sd, Sm	14	17
  VSQRT.F64 Dd, Dm	28	31
  VCVT.F32.F64 Sd, Dm	1	4
  VCVT.F64.F32 Dd, Sm	1	4
  VCVT.F32.S32 Sd, Sm	1	4
  VCVT.F64.S32 Dd, Sm	1	4
  VCVT.S32.F32 Sd, Sm	1	4
  VCVT.S32.F64 Sd, Dm	1	4
  VCVT.F32.S32 Sd, Sd, #fbits	1	4
  VCVT.F64.S32 Dd, Dd, #fbits	1	4
  VCVT.S32.F32 Sd, Sd, #fbits	1	4
  VCVT.S32.F64 Dd, Dd, #fbits	1	4
  1 5 cycles with dependency only on accumulator. 2 8 cycles with dependency only on accumulator.
  NEON integer instructions	Issue cycles	Result latency
  VADD.I8 Dd, Dn, Dm	1	4
  VADDL.S8 Qd, Dn, Dm	2	4
  VADD.I8 Qd, Qn, Qm	2	4
  VMUL.I8 Dd, Dn, Dm	2	4
  VMULL.S8 Qd, Dn, Dm	2	4
  VMUL.I8 Qd, Qn, Qm	4	4
  VMLA.I8 Dd, Dn, Dm	2	4
  VMLAL.S8 Qd, Dn, Dm	2	4
  VMLA.I8 Qd, Qn, Qm	4	4
  VADD.I16 Dd, Dn, Dm	1	4
  VADDL.S16 Qd, Dn, Dm	2	4
  VADD.I16 Qd, Qn, Qm	2	4
  VMUL.I16 Dd, Dn, Dm	1	4
  VMULL.S16 Qd, Dn, Dm	2	4
  VMUL.I16 Qd, Qn, Qm	2	4
  VMLA.I16 Dd, Dn, Dm	1	4
  VMLAL.S16 Qd, Dn, Dm	2	4
  VMLA.I16 Qd, Qn, Qm	2	4
  VADD.I32 Dd, Dn, Dm	1	4
  VADDL.S32 Qd, Dn, Dm	2	4
  VADD.I32 Qd, Qn, Qm	2	4
  VMUL.I32 Dd, Dn, Dm	2	4
  VMULL.S32 Qd, Dn, Dm	2	4
  VMUL.I32 Qd, Qn, Qm	4	4
  VMLA.I32 Dd, Dn, Dm	2	4
  VMLAL.S32 Qd, Dn, Dm	2	4
  VMLA.I32 Qd, Qn, Qm	4	4
  NEON floating-point instructions	Issue cycles	Result latency
  VADD.F32 Dd, Dn, Dm	2	4
  VADD.F32 Qd, Qn, Qm	4	4
  VMUL.F32 Dd, Dn, Dm	2	4
  VMUL.F32 Qd, Qn, Qm	4	4
  VMLA.F32 Dd, Dn, Dm	2	81
  VMLA.F32 Qd, Qn, Qm	4	81
  1 5 cycles with dependency only on accumulator.
  NEON permute instructions	Issue cycles	Result latency
  VEXT.n Dd, Dn, Dm, #imm	1	4
  VEXT.n Qd, Qn, Qm, #imm	2	5
  VTRN.n Dd, Dn, Dm	2	5
  VTRN.n Qd, Qn, Qm	4	5
  VUZP.n Dd, Dn, Dm	2	5
  VUZP.n Qd, Qn, Qm	4	6
  VZIP.n Dd, Dn, Dm	2	5
  VZIP.n Qd, Qn, Qm	4	6
  VTBL.8 Dd, Dn, Dm	1	4
  VTBL.8 Dd, Dn-Dn+1, Dm	1	4
  VTBL.8 Dd, Dn-Dn+2, Dm	2	5
  VTBL.8 Dd, Dn-Dn+3, Dm	2	5

• Running a py script in the Cloud

  12 janvier 2018, par Anay Bose

  I’m new to Google’s cloud & Virtual Machine(VM) instances, and I need some clarifications on a couple of points. I have a python script ; it imports a long range of functions. I need to run those functions in parallel. I’m using multiprocessing and Process, not threads. These functions are basically image and media processors, and they use many other tools like FFMPEG, imagemagick and Avisynth in addition to a wide range of python modules, including moviepy. Now, I would like to run some 50 functions in parallel assigning a CPU for each process. Images, media and avi files are stored in seperate folders. I’m on Windows7 Core-i7 machine. So, need cloud computing power.

  Now, my question can I run such a python script/app in the cloud that requires a very complicated file system and non-python tools i.e. ffmpeg, avisynth and avi files ?

  Can Google VMs emulate my local machine and empower me with more cores and memory to run such a program ? if not, then what are my options ? Is their any tutorials that I can follow ? I need your suggestions. I have given below an example script and some codes to help facilitate your understanding about my situation.

  from __future__ import unicode_literals
  
  import youtube_dl
  
  import os
  
  import time
  
  import sys
  
  reload(sys)  
  
  sys.setdefaultencoding('utf-8')
  
  from multiprocessing import Process
  
  from utils import *
  
  
  
  from clip31 import VIDEO31
  
  from clip32 import VIDEO32
  
  from clip189 import VIDEO189
  
  from clip16 import VIDEO16
  
  from clip39 import VIDEO39
  
  
  
  
  
  if __name__== '__main__':
  
  
  
      # 1. CALLING A FUNCTION
  
      folder = "bodyforce3\\16"
  
      serial = "16"
  
      images = get_filepaths("../16")
  
      videos = get_filepaths("12__media")
  
      pngs = get_filepaths("../pngs")
  
  
  
      Process(target=VIDEO192, args=(folder, serial, color1, color2, color3, images, videos)).start()
  
  
  
  
  
      # 2. CALLING A FUNCTION
  
      folder = "bodyforce3\\20"
  
      serial = "20"
  
      images = get_filepaths("../20")
  
      videos = get_filepaths("18__media")
  
  
  
      Process(target=VIDEO32, args=(folder, serial, color1, color2, color3, images, videos)).start()
  
  
  
  
  
      # 3. CALLING A FUNCTION
  
      folder = "bodyforce3\\14"
  
      serial = "14"
  
      images = get_filepaths("../14")
  
      videos = get_filepaths("16__media")
  
  
  
      Process(target=VIDEO91, args=(folder, serial, color1, color2, color3, images, videos)).start()

  I copy avi files in functions like this :

  src = "clip50_files"
  
  src_files = os.listdir(src)
  
  for file_name in src_files:
  
      full_file_name = os.path.join(src, file_name)
  
      if (os.path.isfile(full_file_name)):
  
          shutil.copy(full_file_name, folder)

  I call ffmpeg commands like this, and they are included within py functions.

  ###########################
  
  #### FFMPEG OPERATIONS ####
  
  ###########################
  
  
  
  print "Starting FFMPEG operations ..."
  
  
  
  if os.path.isfile(os.path.join(folder, "bounce-(3).avi")):
  
      os.remove(os.path.join(folder, "bounce-(3).avi"))
  
  
  
  
  
  infile = folder + "/bounce-(3).avs"
  
  outfile = folder + "/bounce-(3).avi"
  
  codec = "rawvideo"
  
  pix_fmt = "bgra"
  
  
  
  try:
  
      subprocess.call(["ffmpeg",
  
                       "-i" ,infile, 
  
                       "-c:v" ,codec, 
  
                       "-pix_fmt", pix_fmt, 
  
                       outfile],
  
                      stdout=open(os.devnull, 'w'), 
  
                      stderr=subprocess.STDOUT)
  
  except subprocess.CalledProcessError as e:   
  
      #except subprocess.CalledProcessError as e:
  
      sys.exit(e.output)
  
  except OSError as e:
  
      sys.exit(e.strerror)
  
  
  
  
  
  print "FFMPEG operations ended"