Recherche avancée

Sur d’autres sites (5395)

• avcodec/nvenc : surface allocation reduction

  25 avril 2017, par Ben Chang

  avcodec/nvenc : surface allocation reduction
  This patch aims to reduce the number of input/output surfaces
  
  NVENC allocates per session. Previous default sets allocated surfaces to 32
  
  (unless there is user specified param or lookahead involved). Having large
  
  number of surfaces consumes extra video memory (esp for higher resolution
  
  encoding). The patch changes the surfaces calculation for default, B-frames,
  
  lookahead scenario respectively.
  The other change involves surface selection. Previously, if a session
  
  allocates x surfaces, only x-1 surfaces are used (due to combination
  
  of output delay and lock toggle logic). To prevent unused surfaces,
  
  changing surface rotation to using predefined fifo.
  Signed-off-by : Timo Rothenpieler <timo@rothenpieler.org>
  

  • [DH] libavcodec/nvenc.c
  • [DH] libavcodec/nvenc.h
  • [DH] libavcodec/nvenc_h264.c
  • [DH] libavcodec/nvenc_hevc.c

• avcodec/libx265 : use x265 Multi-library Interface to query the API

  7 mai 2015, par Gopu Govindaswamy

  avcodec/libx265 : use x265 Multi-library Interface to query the API
  ffmpeg can now use the x265 multi-library interface to make a runtime
  
  selection between a number of libx265 libraries (perhaps 8bpp and 16bpp).
  ffmpeg will link to one build of libx265 (statically or
  
  dynamically) and this linked version of libx265 will support one
  
  bit-depth (8 or 10 bits). At runtime, ffmpeg now has the option to request the
  
  encoder to use a different bit depth(8 or 10). If the requested bitdepth
  
  is zero, or if it matches the bitdepth of the system default libx265 (the
  
  currently linked library), then this library will be used for encode.
  
  If ffmpeg requests a different bit-depth, the linked libx265 will attempt
  
  to dynamically bind a shared library with the requested bit-depth from the install
  
  location (default or user-specified).
  new x265 API :
  
       const x265_api* api = x265_api_get(int bitDepth) ;
  
       x265_api - holds the libx265 public API functions
  
       bitDepth - requested API for 8bpp or 16bpp
       note : Use 0 to indicate native bit depth of the linked libx265 and
  
             x265_api_get(0) is guaranteed to return a non-null pointer
  Signed-off-by : Gopu Govindaswamy <gopu@multicorewareinc.com>
  
  Signed-off-by : Derek Buitenhuis <derek.buitenhuis@gmail.com>
  

  • [DH] configure
  • [DH] libavcodec/libx265.c

• How to select a rectangle of the screen to capture by dragging mouse on transparent background with wxPython ?

  4 août 2019, par makrottk

  I’m working on building an application to capture screen with ffmpeg and would like to determine the portion of the screen to capture by dragging the mouse, drawing a rectangle and passing the arguments to the ffmpeg call.

  I’m using wxPython to build a simple GUI for the application. I’ve gotten to the point where I can draw the rectangle and get the coordinates that I want : offset and size of the selected area.

  import wx
  
  
  
  global selectionOffset, selectionSize
  
  
  
  selectionOffset = ""
  
  selectionSize = ""
  
  
  
  class SelectableFrame(wx.Frame):
  
  
  
      c1 = None
  
      c2 = None
  
  
  
      def __init__(self, parent=None, id=wx.ID_ANY, title=""):
  
          wx.Frame.__init__(self, parent, id, title, size=wx.DisplaySize(), style=wx.TRANSPARENT_WINDOW)
  
  
  
          self.Bind(wx.EVT_MOTION, self.OnMouseMove)
  
          self.Bind(wx.EVT_LEFT_DOWN, self.OnMouseDown)
  
          self.Bind(wx.EVT_LEFT_UP, self.OnMouseUp)
  
          self.Bind(wx.EVT_PAINT, self.OnPaint)
  
  
  
          self.SetCursor(wx.Cursor(wx.CURSOR_CROSS))
  
  
  
      def OnMouseMove(self, event):
  
          if event.Dragging() and event.LeftIsDown():
  
              self.c2 = event.GetPosition()
  
              self.Refresh()
  
  
  
      def OnMouseDown(self, event):
  
          self.c1 = event.GetPosition()
  
  
  
      def OnMouseUp(self, event):
  
          self.SetCursor(wx.Cursor(wx.CURSOR_ARROW))
  
          self.Destroy()
  
  
  
      def OnPaint(self, event):
  
          global selectionOffset, selectionSize
  
          if self.c1 is None or self.c2 is None: return
  
  
  
          dc = wx.PaintDC(self)
  
          dc.SetPen(wx.Pen('red', 1))
  
          dc.SetBrush(wx.Brush(wx.Colour(0, 0, 0), wx.TRANSPARENT))
  
  
  
          dc.DrawRectangle(self.c1.x, self.c1.y, self.c2.x - self.c1.x, self.c2.y - self.c1.y)
  
          selectionOffset = str(self.c1.x) + "x" + str(self.c1.y)
  
          selectionSize = str(abs(self.c2.x - self.c1.x)) + "x" + str(abs(self.c2.y - self.c1.y))
  
      def PrintPosition(self, pos):
  
          return str(pos.x) + "x" + str(pos.y)
  
  
  
  
  
  class MyApp(wx.App):
  
  
  
      def OnInit(self):
  
          frame = SelectableFrame()
  
          frame.Show(True)
  
          self.SetTopWindow(frame)
  
  
  
          return True
  
  
  
  
  
  app = MyApp(redirect=False)
  
  app.MainLoop()
  
  print("offset: " + selectionOffset + ". Screen selection size: " + selectionSize)

  The problem is I can’t get the "background" to be transparent so I can see which portion of the screen I’m really grabbing. How can I do that with wxPython ? If there’s an easier way with another GUI tool or python module I’m open to suggestions. Thanks !