Recherche avancée

Sur d’autres sites (6060)

• How to efficiently create H264 mpeg from two clips with known different motion intensity ?

  14 février 2017, par Serge

  Given an audio and an image we create a static image "video" and then append a short clip that has a rather intense motion.

  Audio and image varies from run to run. Appended animation is always the same. Rendering is done with ffmpeg on a remote server. Rendered file must be in h264 codec mpg.

  Speed of encoding is crucial. Is there a fast and effective way to generate and merge the two clips quickly ?

  Atm we use the following ffmpeg commands :

  // create first clip from image
  
  ffmpeg -loop 1 -r 24 -i $IMAGE -i $AUDIO -t $AUDIO_LENGTH -c:a aac -profile:a aac_low -ar 48000 -b:a 192k -bsf:a aac_adtstoasc -strict -2 -y -c:v libx264 -profile:v high -preset veryfast  -tune stillimage -crf 24 -x264opts bframes=2 -pix_fmt yuv420p -safe 0  clip1.mpg
  
  // . . .
  
  // then append the animation
  
  ffmpeg -f concat -safe 0 -i list.txt -c copy -y -safe 0 final.mpg 

  Intuition is that we can benefit form knowing exact timing of a first clip with a static image and the second one with intense animation – like it is determined in the 1-st pass of a 2-pass compression.

  Someone experienced in tech of h264 codec and mpeg please advice.

• Animating a 2D plot (2D brownian motion) not working in Python

  8 avril 2020, par Thamu Mnyulwa

  I am trying to plot a 2D Brownian motion in Python but my plot plots the grid but does not animate the line.

  



  Attempted at performing this plot is below,

  



  !apt install ffmpeg

import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt
import matplotlib.animation as animation


np.random.seed(5)


# Set up formatting for the movie files
Writer = animation.writers['ffmpeg']
writer = Writer(fps=15, metadata=dict(artist='Me'), bitrate=1800)


def generateRandomLines(dt, N):
    dX = np.sqrt(dt) * np.random.randn(1, N)
    X = np.cumsum(dX, axis=1)

    dY = np.sqrt(dt) * np.random.randn(1, N)
    Y = np.cumsum(dY, axis=1)

    lineData = np.vstack((X, Y))

    return lineData


# Returns Line2D objects
def updateLines(num, dataLines, lines):
    for u, v in zip(lines, dataLines):
        u.set_data(v[0:2, :num])

    return lines

N = 501 # Number of points
T = 1.0
dt = T/(N-1)


fig, ax = plt.subplots()

data = [generateRandomLines(dt, N)]

ax = plt.axes(xlim=(-2.0, 2.0), ylim=(-2.0, 2.0))

ax.set_xlabel('X(t)')
ax.set_ylabel('Y(t)')
ax.set_title('2D Discretized Brownian Paths')

## Create a list of line2D objects
lines = [ax.plot(dat[0, 0:1], dat[1, 0:1])[0] for dat in data]


## Create the animation object
anim = animation.FuncAnimation(fig, updateLines, N+1, fargs=(data, lines), interval=30, repeat=True, blit=False)

plt.tight_layout()
plt.show()

## Uncomment to save the animation
#anim.save('brownian2d_1path.mp4', writer=writer)


  



  However, instead of performing the plot the program is printing,


  



  How do I animate this plot ? I am new to python so I apologize in advanced if this is an easy question.

  



  I found this question on http://people.bu.edu/andasari/courses/stochasticmodeling/lecture5/stochasticlecture5.html , there is a walkthrough of how this code came to being.

  


• Lossless Video Compression formats

  26 novembre 2019, par jippyjoe4

  I create lots of 4K 60fps 3D animations, and every frame of these animations are exported as separate PNG files to my disk drive. These PNG files use their own lossless compression method, but the file sizes are still quite large (a 30 second animation can take anywhere between 4 and 18 GB). I’m interested in alternative lossless compression formats to reduce the file sizes even further.

  The reason I’m interested in lossless compression is because I create a LARGE variety of animations, and lossy algorithms are not always consistent in terms of visual fidelity (what doesn’t create visible artifacts for one animation might for another).

  Do you have good recommendations for general purpose lossless video codecs that can achieve superior performance to storing the PNG frames individually ?

  So far, I have attempted to use h.265 lossless using ffmpeg :

  ffmpeg -r 60 -i out%04d.png -c:v libx265 -preset ultrafast -x265-params lossless=1 OUTPUT.mp4

  But the result was a 15.4GB file when the original PNG files themselves only took up 5.77 GB in total. I assume this was because, for this particular animation, interframe compression was far worse than intraframe compression, but I don’t really know.

  I understand that this is highly dependent on the content I’m attempting to compress, but I’m just hoping that I can find something that’s better than storing the frames individually.