Recherche avancée

Sur d’autres sites (8257)

• How to match the video bitrate of opencv with ffmpeg ?

  24 avril 2019, par user10890282

  I am trying to read three cameras simultaneously one of which is done through a video grabber card. I want to be able to stream the data and also write out videos from these sources. I used FFmpeg to write out the data from the video grabber card and OpenCV writer for the normal USB cameras. But the bit rates of the files do not match nor does the size. This becomes a problem as I post-process the files. I tried to convert the OpenCV written files using FFmpeg later but the duration of the files still remain different though the bit rates have changed. I really would appreciate pointers to know how to go about this from the script itself. The ideal case would be that I use FFmpeg for all the three sources with the same settings. But how can I do this without spitting out all the information on the console as writing out the files, since there would have to be three sources written out simultaneously ? Could someone tell me how to have multiple FFmpeg threads going on for writing out files while streaming videos using OpenCV ?

  I have attached my current code with OpenCV writer and FFmpeg for one source :

  from threading import Thread
  
  import cv2
  
  import time
  
  import sys
  
  import subprocess as sp
  
  import os
  
  import datetime
  
  old_stdout=sys.stdout
  
  
  
  
  
  
  
  maindir= "E:/Trial1/"
  
  os.chdir(maindir)
  
  maindir=os.getcwd()
  
  
  
  class VideoWriterWidget(object):
  
      def __init__(self, video_file_name, src=0):
  
          if (src==3):
  
              self.frame_name= "Cam_"+str(src)+"(Right)"
  
          if(src==2):
  
              self.frame_name= "Cam_"+str(src)+"(Left)" 
  
          # Create a VideoCapture object
  
          #self.frame_name =str(src)
  
          self.video_file = video_file_name+"_"
  
          self.now=datetime.datetime.now()
  
          self.ts=datetime.datetime.now()
  
          self.video_file_nameE="{}.avi".format("Endo_"+self.ts.strftime("%Y%m%d_%H-%M-%S"))
  
          self.video_file_name = "{}.avi".format(video_file_name+self.ts.strftime("%Y%m%d_%H-%M-%S"))
  
          self.FFMPEG_BIN = "C:/ffmpeg/bin/ffmpeg.exe"
  
          self.command=[self.FFMPEG_BIN,'-y','-f','dshow','-rtbufsize','1024M','-video_size','640x480','-i', 'video=Datapath VisionAV Video 01','-pix_fmt', 'bgr24', '-r','60', self.video_file_name]
  
          self.capture = cv2.VideoCapture(src)
  
  
  
          # Default resolutions of the frame are obtained (system dependent)
  
  
  
          self.frame_width = int(self.capture.get(3))#480
  
          self.frame_height = int(self.capture.get(4))# 640
  
  
  
  
  
          # Set up codec and output video settings
  
          if(src==2 or src==3):
  
              self.codec = cv2.VideoWriter_fourcc('M','J','P','G')
  
              self.output_video = cv2.VideoWriter(self.video_file_name, self.codec, 30, (self.frame_width, self.frame_height))
  
  
  
          # Start the thread to read frames from the video stream
  
              self.thread = Thread(target=self.update, args=(src,))
  
              self.thread.daemon = True
  
              self.thread.start()
  
  
  
          # Start another thread to show/save frames
  
              self.start_recording()
  
              print('initialized {}'.format(self.video_file))
  
  
  
          if (src==0):
  
              self.e_recording_thread = Thread(target=self.endo_recording_thread, args=())
  
              self.e_recording_thread.daemon = True
  
              self.e_recording_thread.start() 
  
              print('initialized endo recording')
  
  
  
  
  
      def update(self,src):
  
          # Read the next frame from the stream in a different thread
  
          while True:
  
              if self.capture.isOpened():
  
                  (self.status, self.frame) = self.capture.read()
  
                  if (src==3):
  
                      self.frame= cv2.flip(self.frame,-1) 
  
  
  
  
  
      def show_frame(self):
  
          # Display frames in main program
  
          if self.status:
  
              cv2.namedWindow(self.frame_name, cv2.WINDOW_NORMAL)
  
              cv2.imshow(self.frame_name, self.frame)
  
  
  
  
  
          # Press Q on keyboard to stop recording0000
  
          key = cv2.waitKey(1)
  
          if key == ord('q'):#
  
              self.capture.release()
  
              self.output_video.release()
  
              cv2.destroyAllWindows()
  
              exit(1)
  
  
  
      def save_frame(self):
  
          # Save obtained frame into video output file
  
          self.output_video.write(self.frame)
  
  
  
      def start_recording(self):
  
          # Create another thread to show/save frames
  
          def start_recording_thread():
  
              while True:
  
                  try:
  
                      self.show_frame()
  
                      self.save_frame()
  
                  except AttributeError:
  
                      pass
  
          self.recording_thread = Thread(target=start_recording_thread, args=())
  
          self.recording_thread.daemon = True
  
          self.recording_thread.start()
  
  
  
      def endo_recording_thread(self):
  
           self.Pr1=sp.call(self.command)
  
  
  
  
  
  
  
  if __name__ == '__main__':
  
      src1 = 'Your link1'
  
      video_writer_widget1 = VideoWriterWidget('Endo_', 0)
  
      src2 = 'Your link2'
  
      video_writer_widget2 = VideoWriterWidget('Camera2_', 2)
  
      src3 = 'Your link3'
  
      video_writer_widget3 = VideoWriterWidget('Camera3_', 3)
  
  
  
      # Since each video player is in its own thread, we need to keep the main thread alive.
  
      # Keep spinning using time.sleep() so the background threads keep running
  
      # Threads are set to daemon=True so they will automatically die 
  
      # when the main thread dies
  
      while True:
  
        time.sleep(5)

• Evolution #4468 : Unification des CSS pour les boutons et les icônes

  15 septembre 2020

  @b_b : Super, merci

  @jluc : Ah je pensais qu’on pouvait au moins éditer ses propres tickets sur trac, même sans être admin. Je viens de voir que j’aurais pu le faire moi-même d’ailleurs, mais je me suis encore fait avoir par l’UX : faut d’abord cliquer sur modifier, et ensuite sur la petite icône « changer la description ». Mon cerveau refuse de retenir ce truc.

  Alors en fin de compte j’ai fait en sorte de ranger un minimum, mais en essayant de pas toucher à trop de choses non plus :

  • Tout ce qui a trait aux boutons est dans un nouveau module boutons.css : les boutons de formulaires, les boutons d’action, et la nouvelle classe lambda .bouton.
  • Je n’ai pas touché au bando rapide, donc pour les nouveaux boutons le sélecteur CSS inclus le tag : a.bouton. Je disais que c’est sale parcequ’en dehors des règles de base (reset, typo…), la règle générale c’est d’éviter de cibler un tag en particulier.

  En parlant de rangement, le module icons.css contient aussi les onglets (barre + onglets simples). À mon avis le composant .icone.horizontale|verticale ça rentre dans la famille des boutons, donc à déplacer dans le module boutons.css, et le module icons pourrait ensuite être renommé en onglets.css.
  Mais bon, j’y touche pas, ça pourra faire l’objet d’un autre ticket spécifiquement pour le découpage et le rangement des modules.

  Je vais essayer de boucler ça demain, y a moyen de faire un PR pour tenter de squeezer ça dans l’alpha de la 3.3 amha.
  J’y mettrai un description complète de la prop incluant les derniers correctifs.

• Problems using libavfilter for adding overlay to frames

  12 novembre 2024, par Michael Werner

  On Windows 11 OS with latest libav (full build) a C/C++ app reads YUV420P frames from a frame grabber card.

  


  I want to draw a bitmap (BGR24) overlay image from file on every frame via libavfilter. First I convert the BGR24 overlay image via format filter to YUV420P. Then I feed the YUV420P frame from frame grabber and the YUV420P overlay into the overlay filter.

  


  Everything seems to be fine but when I try to get the frame out of the filter graph I always get an "Resource is temporary not available" (EAGAIN) return code, independent on how many frames I put into the graph.

  


  The frames from the frame grabber card are fine, I could encode them or write them to a .yuv file. The overlay frame looks fine too.

  


  My current initialization code looks like below. It does not report any errors or warnings but when I try to get the filtered frame out of the graph via av_buffersink_get_frame I always get an EAGAIN return code.

  


  Here is my current initialization code :

  


  int init_overlay_filter(AVFilterGraph** graph, AVFilterContext** src_ctx, AVFilterContext** overlay_src_ctx,
                        AVFilterContext** sink_ctx)
{
    AVFilterGraph* filter_graph;
    AVFilterContext* buffersrc_ctx;
    AVFilterContext* overlay_buffersrc_ctx;
    AVFilterContext* buffersink_ctx;
    AVFilterContext* overlay_ctx;
    AVFilterContext* format_ctx;
    const AVFilter *buffersrc, *buffersink, *overlay_buffersrc, *overlay_filter, *format_filter;
    int ret;

    // Create the filter graph
    filter_graph = avfilter_graph_alloc();
    if (!filter_graph)
    {
        fprintf(stderr, "Unable to create filter graph.\n");
        return AVERROR(ENOMEM);
    }

    // Create buffer source filter for main video
    buffersrc = avfilter_get_by_name("buffer");
    if (!buffersrc)
    {
        fprintf(stderr, "Unable to find buffer filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create buffer source filter for overlay image
    overlay_buffersrc = avfilter_get_by_name("buffer");
    if (!overlay_buffersrc)
    {
        fprintf(stderr, "Unable to find buffer filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create buffer sink filter
    buffersink = avfilter_get_by_name("buffersink");
    if (!buffersink)
    {
        fprintf(stderr, "Unable to find buffersink filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create overlay filter
    overlay_filter = avfilter_get_by_name("overlay");
    if (!overlay_filter)
    {
        fprintf(stderr, "Unable to find overlay filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Create format filter
    format_filter = avfilter_get_by_name("format");
    if (!format_filter) 
    {
        fprintf(stderr, "Unable to find format filter.\n");
        return AVERROR_FILTER_NOT_FOUND;
    }

    // Initialize the main video buffer source
    char args[512];
    snprintf(args, sizeof(args),
             "video_size=1920x1080:pix_fmt=yuv420p:time_base=1/25:pixel_aspect=1/1");
    ret = avfilter_graph_create_filter(&buffersrc_ctx, buffersrc, "in", args, NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer source filter for main video.\n");
        return ret;
    }

    // Initialize the overlay buffer source
    snprintf(args, sizeof(args),
             "video_size=165x165:pix_fmt=bgr24:time_base=1/25:pixel_aspect=1/1");
    ret = avfilter_graph_create_filter(&overlay_buffersrc_ctx, overlay_buffersrc, "overlay_in", args, NULL,
                                       filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer source filter for overlay.\n");
        return ret;
    }

    // Initialize the format filter to convert overlay image to yuv420p
    snprintf(args, sizeof(args), "pix_fmts=yuv420p");
    ret = avfilter_graph_create_filter(&format_ctx, format_filter, "format", args, NULL, filter_graph);

    if (ret < 0) 
    {
        fprintf(stderr, "Unable to create format filter.\n");
        return ret;
    }

    // Initialize the buffer sink
    ret = avfilter_graph_create_filter(&buffersink_ctx, buffersink, "out", NULL, NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create buffer sink filter.\n");
        return ret;
    }

    // Initialize the overlay filter
    ret = avfilter_graph_create_filter(&overlay_ctx, overlay_filter, "overlay", "W-w:H-h:enable='between(t,0,20)':format=yuv420", NULL, filter_graph);
    if (ret < 0)
    {
        fprintf(stderr, "Unable to create overlay filter.\n");
        return ret;
    }

    // Connect the filters
    ret = avfilter_link(overlay_buffersrc_ctx, 0, format_ctx, 0);

    if (ret >= 0)
    {
        ret = avfilter_link(buffersrc_ctx, 0, overlay_ctx, 0);
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }


    if (ret >= 0) 
    {
        ret = avfilter_link(format_ctx, 0, overlay_ctx, 1);
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    if (ret >= 0) 
    {
        if ((ret = avfilter_link(overlay_ctx, 0, buffersink_ctx, 0)) < 0)
        {
            fprintf(stderr, "Unable to link filter graph.\n");
            return ret;
        }
    }
    else
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    // Configure the filter graph
    if ((ret = avfilter_graph_config(filter_graph, NULL)) < 0)
    {
        fprintf(stderr, "Unable to configure filter graph.\n");
        return ret;
    }

    *graph = filter_graph;
    *src_ctx = buffersrc_ctx;
    *overlay_src_ctx = overlay_buffersrc_ctx;
    *sink_ctx = buffersink_ctx;

    return 0;
}


  


  Feeding the filter graph is done this way :

  


  av_buffersrc_add_frame_flags(buffersrc_ctx, pFrameGrabberFrame, AV_BUFFERSRC_FLAG_KEEP_REF)
av_buffersink_get_frame(buffersink_ctx, filtered_frame)


  


  av_buffersink_get_frame returns always EAGAIN, no matter how many frames I feed into the graph. The frames (from framegrabber and the overlay frame) itself are looking fine.

  


  I did set libav logging level to maximum but I do not see any warnings or errors or helpful, related information in the log.

  


  Here the log output related to the filter configuration :

  


  [in @ 00000288ee494f40] Setting 'video_size' to value '1920x1080'
[in @ 00000288ee494f40] Setting 'pix_fmt' to value 'yuv420p'
[in @ 00000288ee494f40] Setting 'time_base' to value '1/25'
[in @ 00000288ee494f40] Setting 'pixel_aspect' to value '1/1'
[in @ 00000288ee494f40] w:1920 h:1080 pixfmt:yuv420p tb:1/25 fr:0/1 sar:1/1 csp:unknown range:unknown
[overlay_in @ 00000288ff1013c0] Setting 'video_size' to value '165x165'
[overlay_in @ 00000288ff1013c0] Setting 'pix_fmt' to value 'bgr24'
[overlay_in @ 00000288ff1013c0] Setting 'time_base' to value '1/25'
[overlay_in @ 00000288ff1013c0] Setting 'pixel_aspect' to value '1/1'
[overlay_in @ 00000288ff1013c0] w:165 h:165 pixfmt:bgr24 tb:1/25 fr:0/1 sar:1/1 csp:unknown range:unknown
[format @ 00000288ff1015c0] Setting 'pix_fmts' to value 'yuv420p'
[overlay @ 00000288ff101880] Setting 'x' to value 'W-w'
[overlay @ 00000288ff101880] Setting 'y' to value 'H-h'
[overlay @ 00000288ff101880] Setting 'enable' to value 'between(t,0,20)'
[overlay @ 00000288ff101880] Setting 'format' to value 'yuv420'
[auto_scale_0 @ 00000288ff101ec0] w:iw h:ih flags:'' interl:0
[format @ 00000288ff1015c0] auto-inserting filter 'auto_scale_0' between the filter 'overlay_in' and the filter 'format'
[auto_scale_1 @ 00000288ee4a4cc0] w:iw h:ih flags:'' interl:0
[overlay @ 00000288ff101880] auto-inserting filter 'auto_scale_1' between the filter 'format' and the filter 'overlay'
[AVFilterGraph @ 00000288ee495c80] query_formats: 5 queried, 6 merged, 6 already done, 0 delayed
[auto_scale_0 @ 00000288ff101ec0] w:165 h:165 fmt:bgr24 csp:gbr range:pc sar:1/1 -> w:165 h:165 fmt:yuv420p csp:unknown range:unknown sar:1/1 flags:0x00000004
[auto_scale_1 @ 00000288ee4a4cc0] w:165 h:165 fmt:yuv420p csp:unknown range:unknown sar:1/1 -> w:165 h:165 fmt:yuva420p csp:unknown range:unknown sar:1/1 flags:0x00000004
[overlay @ 00000288ff101880] main w:1920 h:1080 fmt:yuv420p overlay w:165 h:165 fmt:yuva420p
[overlay @ 00000288ff101880] [framesync @ 00000288ff1019a8] Selected 1/25 time base
[overlay @ 00000288ff101880] [framesync @ 00000288ff1019a8] Sync level 2