Recherche avancée

Sur d’autres sites (6608)

• avfilter/vf_dnn_processing : add a generic filter for image proccessing with dnn networks

  31 octobre 2019, par Guo, Yejun

  avfilter/vf_dnn_processing : add a generic filter for image proccessing with dnn networks
  This filter accepts all the dnn networks which do image processing.
  
  Currently, frame with formats rgb24 and bgr24 are supported. Other
  
  formats such as gray and YUV will be supported next. The dnn network
  
  can accept data in float32 or uint8 format. And the dnn network can
  
  change frame size.
  The following is a python script to halve the value of the first
  
  channel of the pixel. It demos how to setup and execute dnn model
  
  with python+tensorflow. It also generates .pb file which will be
  
  used by ffmpeg.
  import tensorflow as tf
  
  import numpy as np
  
  import imageio
  
  in_img = imageio.imread('in.bmp')
  
  in_img = in_img.astype(np.float32)/255.0
  
  in_data = in_img[np.newaxis, :]
  
  filter_data = np.array([0.5, 0, 0, 0, 1., 0, 0, 0, 1.]).reshape(1,1,3,3).astype(np.float32)
  
  filter = tf.Variable(filter_data)
  
  x = tf.placeholder(tf.float32, shape=[1, None, None, 3], name='dnn_in')
  
  y = tf.nn.conv2d(x, filter, strides=[1, 1, 1, 1], padding='VALID', name='dnn_out')
  
  sess=tf.Session()
  
  sess.run(tf.global_variables_initializer())
  
  output = sess.run(y, feed_dict=x : in_data)
  
  graph_def = tf.graph_util.convert_variables_to_constants(sess, sess.graph_def, ['dnn_out'])
  
  tf.train.write_graph(graph_def, '.', 'halve_first_channel.pb', as_text=False)
  
  output = output * 255.0
  
  output = output.astype(np.uint8)
  
  imageio.imsave("out.bmp", np.squeeze(output))
  To do the same thing with ffmpeg :
  
   generate halve_first_channel.pb with the above script
  
   generate halve_first_channel.model with tools/python/convert.py
  
   try with following commands
  
    ./ffmpeg -i input.jpg -vf dnn_processing=model=halve_first_channel.model:input=dnn_in:output=dnn_out:fmt=rgb24:dnn_backend=native -y out.native.png
  
    ./ffmpeg -i input.jpg -vf dnn_processing=model=halve_first_channel.pb:input=dnn_in:output=dnn_out:fmt=rgb24:dnn_backend=tensorflow -y out.tf.png
  Signed-off-by : Guo, Yejun <yejun.guo@intel.com>
  
  Signed-off-by : Pedro Arthur <bygrandao@gmail.com>
  

  • [DH] configure
  • [DH] doc/filters.texi
  • [DH] libavfilter/Makefile
  • [DH] libavfilter/allfilters.c
  • [DH] libavfilter/vf_dnn_processing.c

• FFmpeg Zoom and Rotate Causes Image Cropping Instead of Allowing It to Go Beyond Frame Edges [closed]

  6 octobre 2024, par XVersi

  I am trying to create a zoom-in video with a gentle rotation effect using FFmpeg. My goal is to zoom in on the center of the image while allowing parts of the image to "go beyond" the frame boundaries during the zoom and rotation. However, what I see is that FFmpeg seems to crop the image to fit within the output frame, and instead of keeping the full image intact, it fills the rest of the frame with black sections, effectively trimming parts of my image.

  


  Here is the code I'm using in Go to generate the video using FFmpeg :

  


  func createZoomInVideoWithRotation(ffmpegPath, imagePath, outputPath string) error {
cmd := exec.Command(ffmpegPath, "-i", imagePath, "-vf", `[0:v]scale=9000x5000,zoompan=z='min(zoom+0.002,1.5)':x='iw/2-(iw/zoom/2)':y='ih/2-(ih/zoom/2)':d=125,rotate='PI/800*t',trim=duration=20[v1];[v1]scale=1080:1920[v]`, "-c:v", "libx264", "-crf", "18", "-preset", "slow", outputPath)
err := cmd.Run()
if err != nil {
    return fmt.Errorf("error executing ffmpeg command: %w", err)
}

fmt.Println("Zoom-in and rotation video created successfully!")
return nil
}

func main() {
    ffmpegPath := `C:\Users\username\Downloads\ffmpeg-7.0.2-essentials_build\ffmpeg-7.0.2-essentials_build\bin\ffmpeg.exe`
    imagePath := `C:\Users\username\video_proj\image.jpg` 
    outputPath := `C:\Users\username\video_proj\output_zoom_rotate.mp4`



err := createZoomInVideoWithRotation(ffmpegPath, imagePath, outputPath)
if err != nil {
    fmt.Println("Error creating zoom and rotate video:", err)
}
}


  


  Removing the final scale=1080:1920 : I removed the scale part at the end of the filter chain to prevent FFmpeg from resizing the video to a fixed size, hoping that this would allow the image to remain at its original size without being cropped to fit the frame.

  


  The image would zoom in on its center and rotate, and during this process, parts of the image would be allowed to move beyond the boundaries of the video output frame.
There would be no cropping or resizing of the image, meaning the full original image would be intact even if it extends beyond the video frame.
Essentially, I wanted the image to "overflow" outside of the set dimensions during the rotation, without being forced to fit within the output frame and without adding black borders that indicate missing parts of the image.

  


• How Do I Get Python To Capture My Screen At The Right Frame Rate

  14 juillet 2024, par John Thesaurus

  I have this python script that is supposed to record my screen, on mac os.

  


  import cv2
import numpy as np
from PIL import ImageGrab
import subprocess
import time

def record_screen():
    # Define the screen resolution
    screen_width, screen_height = 1440, 900  # Adjust this to match your screen resolution
    fps = 30  # Target FPS for recording

    # Define the ffmpeg command
    ffmpeg_cmd = [
        'ffmpeg',
        '-y',  # Overwrite output file if it exists
        '-f', 'rawvideo',
        '-vcodec', 'rawvideo',
        '-pix_fmt', 'bgr24',
        '-s', f'{screen_width}x{screen_height}',  # Size of one frame
        '-r', str(fps),  # Input frames per second
        '-i', '-',  # Input from pipe
        '-an',  # No audio
        '-vcodec', 'libx264',
        '-pix_fmt', 'yuv420p',
        '-crf', '18',  # Higher quality
        '-preset', 'medium',  # Encoding speed
        'screen_recording.mp4'
    ]

    # Start the ffmpeg process
    ffmpeg_process = subprocess.Popen(ffmpeg_cmd, stdin=subprocess.PIPE)

    frame_count = 0
    start_time = time.time()

    while True:
        # Capture the screen
        img = ImageGrab.grab()
        img_np = np.array(img)

        # Convert and resize the frame
        frame = cv2.cvtColor(img_np, cv2.COLOR_RGB2BGR)
        resized_frame = cv2.resize(frame, (screen_width, screen_height))

        # Write the frame to ffmpeg
        ffmpeg_process.stdin.write(resized_frame.tobytes())

        # Display the frame
        cv2.imshow('Screen Recording', resized_frame)

        # Stop recording when 'q' is pressed
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    # Close the ffmpeg process
    ffmpeg_process.stdin.close()
    ffmpeg_process.wait()

    # Release everything when job is finished
    cv2.destroyAllWindows()

if __name__ == "__main__":
    record_screen()




  


  As you can see, it should be 30 frames per second, but the problem is that when I open the file afterwards its all sped up. I think it has to do with the frame capture rate as oppose to the encoded rate. I'm not quite sure though. If I try to speed the video down afterwards so that it plays in real time the video is just really choppy. And the higher I make the fps, the faster the video plays, meaning the more I have to slow it down and then its still choppy. I'm pretty sure that it captures frames at a really slow rate and then puts them in a video and plays it back at 30fps. Can anyone fix this ? Anything that gets a working screen recorder on mac os I will take.