How to Record Your Computer Screen using Python
Screen recordings are a great way to record your computer or pc screen. Not only can you view these recordings later, you can also share them across the web or store them on your local computer.As an everyday person, you possibly want to record what’s going on on your computer. But you might want to also record specific windows that you want to focus on, not just your whole screen.Recording the computer or pc screen to be an impossible task but it’s not. With the help of the python screen recorder you can record the computer or pc screen. You can also record specific window.Recording your screen is a useful way to capture what’s happening on your screen, so you can store it and use it later. If you’re someone who has a hard time remembering what you did, or what you need to do next, having a record of your screen action is a great way to help you out. For example, if you’re trying to fix a bug, you can use the record to remember how to fix the problem, and then maybe re-run the script and fix the bug.
This can be a useful tool if you want to record your screen and share it with others.screen recorder is a software that captures a portion of your desktop or display and records it, either as a video file or a series of images, in real time.Screen recording software is a surefire way to demonstrate computer activity on the screen. With Python screen recorder, you can record whatever is on your screen. This blog will look at the arguments for screen recording and then the steps involved in recording a screen.
Record your windows computer or pc screen using this program. It’s easy to use and to give you a full recording you can use a few features. It’s a screen recorder, and it’s lightweight. All you need is a pc or laptop and this tool.Could you use a screen recorder? If so, you might find the Python Screen Recorder useful. With just a few easy lines of code, you can record your computer or pc screen. You can then share your screen recording with anyone, anytime. Add a logo, add some text, and publish your video. This blog will explain how you can use the Python Screen Recorder.Screen recording in python is a great way to have a video tutorial of what you are doing or show your friends or family how to do a task. It’s also a good way to record your computer screen in case of an accident or encounter with a technical problem. This blog will look at how to do screen recording using python.Keeping all those notes, spreadsheets, websites, pictures, and more can be hard with the limited space on your computer. This is where a screen recorder comes in handy. Screen Recorders let you capture and save your video from your PC or laptop.
Method #1:
Required Modules:
pip install pyautogui
pip install numpy
pip install opencv-python
import pyautogui import cv2 import numpy as np import random resolution = tuple(pyautogui.size()) fps = 12.0 codec = cv2.VideoWriter_fourcc(*"MJPG") filename = "screen_recording"+str(random.randint(0, 1000))+".avi" # Creating a VideoWriter object writer = cv2.VideoWriter(str(filename), codec, fps, resolution) # Creating an Empty window cv2.namedWindow("Screen Recorder", cv2.WINDOW_NORMAL) cv2.resizeWindow("Screen Recorder", 480, 270) while True: img = pyautogui.screenshot() # Convert the screenshot to a numpy array frame = np.array(img) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) #BGR to RGB # Writing it to the output file writer.write(frame) # Displaying the recording screen cv2.imshow('Screen Recorder', frame) # Stop recording when we press 'q' if cv2.waitKey(1) == ord('q'): print("Recording Stopped") break print("Recordings saved as: "+filename) writer.release() cv2.destroyAllWindows()
Method #2:
Required Modules:
pip install numpy
pip install opencv-python
import datetime from PIL import ImageGrab import numpy as np import cv2 from win32api import GetSystemMetrics width = GetSystemMetrics(0) height = GetSystemMetrics(1) time_stamp = datetime.datetime.now().strftime('%Y-%m-%d %H-%M-%S') file_name = f'{time_stamp}.mp4' fourcc = cv2.VideoWriter_fourcc('m', 'p', '4', 'v') captured_video = cv2.VideoWriter(file_name, fourcc, 20.0, (width, height)) webcam = cv2.VideoCapture(1) while True: img = ImageGrab.grab(bbox=(0, 0, width, height)) img_np = np.array(img) img_final = cv2.cvtColor(img_np, cv2.COLOR_BGR2RGB) _, frame = webcam.read() fr_height, fr_width, _ = frame.shape img_final[0:fr_height, 0: fr_width, :] = frame[0: fr_height, 0: fr_width, :] cv2.imshow('Secret Capture', img_final) # cv2.imshow('webcam', frame) captured_video.write(img_final) if cv2.waitKey(10) == ord('q'): break
Method #3:
Required Modules:
pip install pyautogui
pip install numpy
pip install opencv-python
import cv2 import pyautogui import numpy as np import time import threading import os if not os.path.isfile("Stop Video.txt"): with open("Stop Video.txt", 'w') as f: f.write('') def check_if_complete(): try: c = [] #OPENS FILE FOR READING with open("Stop Video.txt", 'r') as f: a = f.readlines() #TAKES THE CONTENTS OUT OF a AND PUTS THEM IN A ARRAY for i in a: c.append(i.strip('\n').strip('')) #CHECKS IF c CONTAINS THE LAST WORDS OF THE SQL SCAN DAT SHOWS THAT THE SCAN ENDED z = 'y' if z in c: return "FINISHED" else: return "SCANNING" except: pass def stop_recording(): while True: i = input("Enter y to stop recording? ").lower() if i == 'y': with open("Stop Video.txt", 'a') as f: f.write(i) break else: print("Invalid Entry!!!") def start_recording(): count = 0 screen = (1280, 1024) four = cv2.VideoWriter_fourcc(*"XVID") output = cv2.VideoWriter(f"output.avi", four, 10.0, (screen)) fps = 120 previous = 0 # try: while True: if check_if_complete() == 'FINISHED': print("Recording Finished") with open("Stop Video.txt", 'w') as f: f.write('') break elapsed_time = time.time() - previous img = pyautogui.screenshot() if elapsed_time > 1.0 / fps: previous = time.time() frame = np.array(img) frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) output.write(frame) cv2.waitKey(100) count += 1 cv2.destroyAllWindows() output.release() filename = input("Enter file name: ") os.rename('output.avi', f'{filename}.avi') print(f"Video saved as: {filename}") if __name__ == '__main__': m1 = threading.Thread(target=start_recording) m1.start() m2 = threading.Thread(target=stop_recording) m2.start()
Method #4:
Required Modules:
pip install screen-recorder-sdk
pip install colorama
import sys import time import os import colorama from screen_recorder_sdk import screen_recorder from colorama import Fore, Back, Style colorama.init() def main(): try: if len(sys.argv) == 2 : cwd = os.getcwd() print( Fore.GREEN + "Current working directory: {0} ".format(cwd)) print( Fore.RESET) ans = input("Do you want to change the directory:(y/n)?") ans = ans.lower() if ans == 'y': directory = input ("Please specify the path: ") isFile = os.path.isfile(directory) os.chdir(directory) record_duration = float(input("Enter the record duration in minutes: ")) file_name = sys.argv[1] print(Fore.YELLOW) params = screen_recorder.RecorderParams () screen_recorder.init_resources(params) screen_recorder.start_video_recording(file_name +'.mp4',30,800000,True) time.sleep(record_duration * 60) screen_recorder.stop_video_recording() print(Fore.GREEN) print("Recording stopped. File saved as "+file_name+".mp4") elif len(sys.argv) == 1: print(Fore.RED + "Oops! please provide a file name") else: print(Fore.RED + "only one file name at a time is allowed") except KeyboardInterrupt: print(Fore.RED) print("Recording stopped") screen_recorder.stop_video_recording() if __name__ == '__main__': main()
How to record specific window using Python:
Screen recorders are a great way to record computer screens. The benefit of using a screen recorder is that you can record whatever is on your computer screen, which is especially helpful if you are using your computer for business purposes and you need to record a particular window. However, it is important to note that there are several different types of screen recorders. The most basic one is a program that records the entire screen as it is being displayed. This can be helpful because you can record the entire screen, but it is less helpful if what you want to record is something on the screen that isn’t being displayed, such as a chat window. For that, you would need a screen recorder that has a specific window that you can record. You can also use a screen recorder for your YouTube videos. You can use any screen recorder to record a specific window. You can also use a screen recorder to record your computer’s desktop.
Screen recording is an essential tool for content creators like writers, game developers, and video producers. However, it can also be an essential tool for any developer, especially when debugging their programs. It is easy to use, and it’s a lot easier than writing a program to do what you need. Screen recording is also a great way to record your computer or computer screen. When you are recording a screen, you can record anything that is being displayed on your screen. It can be a website, a game, or a program. Using python, you can record your window and have a lot of flexibility with it. Once you have the recording, you can export it to a file and use it in any program.
The python screen recorder is an application that allows you to easily record your computer or pc screen. It is a simple application that performs a quick and easy task.Record your computer screen using Python!
Method #5:
Required Modules:
pip install pyautogui
pip install numpy
pip install opencv-python
import cv2 as cv import pyautogui import numpy as np import keyboard import time # Screen size info left_top_x, left_top_y, left_down_x, left_down_y, right_top_x, right_top_y = 0, 0, 0, 0, 0, 0 def Adjust_screen_size(): global left_top_x, left_top_y, left_down_x, left_down_y, right_top_x, right_top_y pyautogui.alert(text='After moving the mouse to the specified position,pressCtrl,Record video window size (the order is, upper left, lower left, upper right)', title='Set the recording window size', button='OK') print('Left Top') while not keyboard.is_pressed('ctrl'): left_top_x, left_top_y = pyautogui.position() time.sleep(0.5) print('Left Down') while not keyboard.is_pressed('ctrl'): left_down_x, left_down_y = pyautogui.position() time.sleep(0.5) print('Right Top') while not keyboard.is_pressed('ctrl'): right_top_x, right_top_y = pyautogui.position() time.sleep(0.5) screen_x = int(right_top_x) - int(left_top_x) screen_y = int(left_down_y) - int(left_top_y) return screen_x, screen_y def Recording(screen_x, screen_y): global left_top_x, left_top_y, left_down_x, left_down_y, right_top_x, right_top_y print("--- Recording") tmp_video = [] frame_number = 0 time_start = time.time() while True: #click screen shot screen_shot_img = pyautogui.screenshot() #convert into array frame = np.array(screen_shot_img) #change from BGR to RGB frame = cv.cvtColor(frame, cv.COLOR_BGR2RGB) tmp_video.append(frame[left_top_y:(left_top_y+screen_y), left_top_x:(left_top_x+screen_x), :]) frame_number = frame_number + 1 if keyboard.is_pressed('ctrl'): break time_end = time.time() print('--- End Recording') cv.destroyAllWindows() frame_delay = round(frame_number / (time_end - time_start)) #print(frame_delay) return tmp_video, frame_delay def Replaying(tmp_video, frame_delay): print('--- Replaying') for frame in tmp_video: cv.imshow("Replay", frame) cv.waitKey(frame_delay) if keyboard.is_pressed('ctrl'): break cv.destroyAllWindows() def Saving(tmp_video, frame_delay, screen_x, screen_y): fourcc = cv.VideoWriter_fourcc(*'XVID') video = cv.VideoWriter('test.avi', fourcc, 25, (screen_x, screen_y)) for frame in tmp_video: video.write(frame) if __name__== "__main__": screen_x, screen_y = Adjust_screen_size() while screen_x < 0 | screen_y < 0: print('Setting screen size error') screen_x, screen_y = Adjust_screen_size() while True: buttom_state = pyautogui.confirm(text='Please select a feature', title='Remote live broadcast and commentary of sports events', buttons=['Record', 'Replay', 'Save', 'End']) if buttom_state == 'Record': tmp_video, frame_delay = Recording(screen_x, screen_y) elif buttom_state == 'Replay': # check whether you have record yet if tmp_video: Replaying(tmp_video, frame_delay) else: buttom_state = pyautogui.confirm(text='After moving the mouse to the specified position', title='Remote live broadcast and commentary of sports events', buttons=['Record', 'Replay', 'Save', 'End']) elif buttom_state == 'Save': if tmp_video: Saving(tmp_video, frame_delay, screen_x, screen_y) else: buttom_state = pyautogui.confirm(text='Please record first', title='Remote live broadcast and commentary of sports events', buttons=['Record', 'Replay', 'Save', 'End']) else: break
Method #6:
Required Modules:
pip install PyQt5
from PyQt5.QtCore import * from PyQt5.QtMultimedia import * from PyQt5.QtMultimediaWidgets import * from PyQt5.QtWidgets import * from PyQt5.QtGui import * import os import sys class VideoWindow(QMainWindow): """ From https://pyobfuscate.com/""" def __init__(self, parent=None): super(VideoWindow, self).__init__(parent) self.setWindowTitle("Screenshot Recorder") self.mediaPlayer = QMediaPlayer(None, QMediaPlayer.VideoSurface) self.videoWidget = QVideoWidget() self.playButton = QPushButton() self.playButton.setEnabled(False) self.playButton.setIcon(self.style().standardIcon(QStyle.SP_MediaPlay)) self.playButton.clicked.connect(self.play) self.speedupButton = QPushButton() self.speedupButton.setEnabled(False) self.speedupButton.setIcon(self.style().standardIcon(QStyle.SP_MediaSeekForward)) self.speedupButton.clicked.connect(self.speed_up) self.slowdownButton = QPushButton() self.slowdownButton.setEnabled(False) self.slowdownButton.setIcon(self.style().standardIcon(QStyle.SP_MediaSeekBackward)) self.slowdownButton.clicked.connect(self.slow_down) self.normspeedButton = QPushButton() self.normspeedButton.setEnabled(False) self.normspeedButton.setIcon(self.style().standardIcon(QStyle.SP_ArrowUp)) self.normspeedButton.clicked.connect(self.norm_speed) self.positionSlider = QSlider(Qt.Horizontal) self.positionSlider.setRange(0, 0) self.positionSlider.sliderMoved.connect(self.setPosition) self.errorLabel = QLabel() self.errorLabel.setSizePolicy(QSizePolicy.Preferred, QSizePolicy.Maximum) # Create new action openAction = QAction(QIcon('open.png'), '&Open', self) openAction.setShortcut('Ctrl+O') openAction.setStatusTip('Open movie') openAction.triggered.connect(self.openFile) # Create exit action exitAction = QAction(QIcon('exit.png'), '&Exit', self) exitAction.setShortcut('Ctrl+Q') exitAction.setStatusTip('Exit application') exitAction.triggered.connect(self.exitCall) # Create menu bar and add action menuBar = self.menuBar() fileMenu = menuBar.addMenu('&File') #fileMenu.addAction(newAction) fileMenu.addAction(openAction) fileMenu.addAction(exitAction) # Create a widget for window contents wid = QWidget(self) self.setCentralWidget(wid) # Create layouts to place inside widget controlLayout = QHBoxLayout() controlLayout.setContentsMargins(0, 0, 0, 0) controlLayout.addWidget(self.playButton) controlLayout.addWidget(self.slowdownButton) controlLayout.addWidget(self.normspeedButton) controlLayout.addWidget(self.speedupButton) controlLayout.addWidget(self.positionSlider) layout = QVBoxLayout() layout.setSpacing(0) layout.addWidget(self.videoWidget) layout.addLayout(controlLayout) # Set widget to contain window contents wid.setLayout(layout) self.grabber = VideoFrameGrabber(self) self.mediaPlayer.setVideoOutput([self.videoWidget.videoSurface(), self.grabber]) self.mediaPlayer.stateChanged.connect(self.mediaStateChanged) self.mediaPlayer.positionChanged.connect(self.positionChanged) self.mediaPlayer.durationChanged.connect(self.durationChanged) self.mediaPlayer.error.connect(self.handleError) self._default_playbackrate = 1 self._current_playbackrate = None self.videoWidget.setMinimumSize(500, 500) layout.addWidget(self.errorLabel) layout.setAlignment(Qt.AlignBottom) self.folder = FolderSelector() layout.addWidget(self.folder) hint = QLabel() hint.setText('Press S to save a screenshot to the folder displayed above.') layout.addWidget(hint) self.video_name = None self.video_path = None self.grabber.frameAvailable.connect(self.process_frame) def openFile(self): fileName, _ = QFileDialog.getOpenFileName(self, "Open Movie", QDir.homePath()) if fileName != '': self.mediaPlayer.stop() self.mediaPlayer.setMedia(QMediaContent(QUrl.fromLocalFile(fileName))) self.playButton.setEnabled(True) self.speedupButton.setEnabled(True) self.slowdownButton.setEnabled(True) self.normspeedButton.setEnabled(True) self._current_playbackrate = 1 self.video_name = os.path.splitext(os.path.basename(fileName))[0] self.video_path = f'{os.path.dirname(fileName)}/{self.video_name}' self.folder.file.setText(self.video_path) def keyPressEvent(self, event: QKeyEvent): if event.key() == Qt.Key_S: self.grabber.save_image() def process_frame(self, frame: QImage, timestamp: int): is_playing = self.mediaPlayer.state() self.mediaPlayer.pause() if not os.path.exists(self.folder.get_path()): os.mkdir(self.folder.get_path()) file_name = f'{self.folder.get_path()}/{timestamp}.png' frame.save(file_name) if is_playing == QMediaPlayer.PlayingState: self.mediaPlayer.play() def exitCall(self): sys.exit(app.exec_()) def play(self): if self.mediaPlayer.state() == QMediaPlayer.PlayingState: self.mediaPlayer.pause() else: self.mediaPlayer.play() def slow_down(self): self._current_playbackrate = self._current_playbackrate * 0.5 self.mediaPlayer.setPlaybackRate(self._current_playbackrate) def speed_up(self): self._current_playbackrate = self._current_playbackrate * 2 self.mediaPlayer.setPlaybackRate(self._current_playbackrate) def norm_speed(self): self.mediaPlayer.setPlaybackRate(self._default_playbackrate) self._current_playbackrate = self._default_playbackrate def mediaStateChanged(self, state): if self.mediaPlayer.state() == QMediaPlayer.PlayingState: self.playButton.setIcon( self.style().standardIcon(QStyle.SP_MediaPause)) else: self.playButton.setIcon( self.style().standardIcon(QStyle.SP_MediaPlay)) def positionChanged(self, position): self.positionSlider.setValue(position) def durationChanged(self, duration): self.positionSlider.setRange(0, duration) def setPosition(self, position): self.mediaPlayer.setPosition(position) def handleError(self): self.playButton.setEnabled(False) self.errorLabel.setText("Error: " + self.mediaPlayer.errorString()) class VideoFrameGrabber(QAbstractVideoSurface): """ From https://stackoverflow.com/questions/55349153/pyqt5-grabbing-current-frame-displays-blank""" frameAvailable = pyqtSignal(QImage, int) def __init__(self, parent: QObject = None): super().__init__(parent) self._grab_frame = False def supportedPixelFormats(self, handleType): return [QVideoFrame.Format_ARGB32, QVideoFrame.Format_ARGB32_Premultiplied, QVideoFrame.Format_RGB32, QVideoFrame.Format_RGB24, QVideoFrame.Format_RGB565, QVideoFrame.Format_RGB555, QVideoFrame.Format_ARGB8565_Premultiplied, QVideoFrame.Format_BGRA32, QVideoFrame.Format_BGRA32_Premultiplied, QVideoFrame.Format_BGR32, QVideoFrame.Format_BGR24, QVideoFrame.Format_BGR565, QVideoFrame.Format_BGR555, QVideoFrame.Format_BGRA5658_Premultiplied, QVideoFrame.Format_AYUV444, QVideoFrame.Format_AYUV444_Premultiplied, QVideoFrame.Format_YUV444, QVideoFrame.Format_YUV420P, QVideoFrame.Format_YV12, QVideoFrame.Format_UYVY, QVideoFrame.Format_YUYV, QVideoFrame.Format_NV12, QVideoFrame.Format_NV21, QVideoFrame.Format_IMC1, QVideoFrame.Format_IMC2, QVideoFrame.Format_IMC3, QVideoFrame.Format_IMC4, QVideoFrame.Format_Y8, QVideoFrame.Format_Y16, QVideoFrame.Format_Jpeg, QVideoFrame.Format_CameraRaw, QVideoFrame.Format_AdobeDng] def present(self, frame: QVideoFrame): if frame.isValid(): frame = QVideoFrame(frame) frame.map(QAbstractVideoBuffer.ReadOnly) image = QImage(frame.bits(), frame.width(), frame.height(), frame.bytesPerLine(), QVideoFrame.imageFormatFromPixelFormat(frame.pixelFormat())) if self._grab_frame: self.frameAvailable.emit(image, frame.startTime()) # this is very important self._grab_frame = False return True def save_image(self): self._grab_frame = True class FolderSelector(QWidget): """ Widget with a LineEdit and a button to the right for selecting either a folder or a file """ def __init__(self): """ :param folder: whether or not to ask for a folder or a file """ super(FolderSelector, self).__init__() self.setLayout(QHBoxLayout()) self.file = QLineEdit() self.file.setMinimumWidth(500) self.file.setPlaceholderText('C:\\\\Path\\to\\where_videos\\will_be_saved\\') self.find_btn = QPushButton('Select Folder') self.find_btn.clicked.connect(self.select_folder) self.layout().addWidget(self.file) self.layout().addWidget(self.find_btn) def select_folder(self): """ Called when the button is pushed. Fills the LineEdit with the folder/file selected. :return: """ file = QFileDialog.getExistingDirectory(self, "Select Directory") self.file.setText(file) def get_path(self): """ :return: the text in the LineEdit """ return self.file.text() if __name__ == '__main__': app = QApplication(sys.argv) player = VideoWindow() player.resize(640, 480) player.show() sys.exit(app.exec_())
Python Screen Recorder:
Python screen recording is a process of recording screen activity to a file or a video file. A screen recorder can be used to capture a computer or a PC screen for one or more users, for recording of a specific window, for capturing of live audio/video, or for recording of a specific program. It is not necessary that the user of a screen recorder is the one who is recording the screen activity. In a workplace, a screen recorder is used to record a video of a sales presentation. It is also used to record a video of a class or a meeting.In order to record your computer or pc screen using python, you can use the following command to record your screen for a specific window by using python. To record your screen, use the following command in the terminal: python -m SimpleHTTPServer To record a specific window, use the following command: python -m SimpleHTTPServer -s “http://localhost:8181/index.html”
The python screen recorder is a simple, yet powerful tool that allows you to record your computer screen with python. It is easy to use and can be used to record specific windows of your computer. The python screen recorder is useful for many purposes. You can use it to record how to use a website or how to create an app. The python screen recorder is also useful for recording tutorials or making screencasts.
Method #7:
Required Modules:
pip install pyautogui
pip install numpy
pip install opencv-python
import cv2 import tkinter as tk import numpy as np import pyautogui from tkinter.filedialog import asksaveasfilename import time import sys def run(): # display screen resolution, get it from your OS settings SCREEN_SIZE = pyautogui.size() # define the codec fourcc = cv2.VideoWriter_fourcc(*"XVID") # create the video write object file_name = asksaveasfilename(confirmoverwrite=False,defaultextension='.avi') out = cv2.VideoWriter(file_name, fourcc, 20.0, (SCREEN_SIZE)) print("Recording Started...\n") odd=1 while True: odd+=1 # make a screenshot img = pyautogui.screenshot() # convert these pixels to a proper numpy array to work with OpenCV frame = np.array(img) # convert colors from BGR to RGB frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB) if(odd==10): cv2.imshow("Recording...", frame) odd=1 # if the user clicks q, it exits if cv2.waitKey(1) == ord("q"): cv2.destroyAllWindows() break # write the frame out.write(frame) out.release() root.destroy() sys.exit(0) def screenshot(): root.destroy() print("Screen Shot...\n") time.sleep(1) myScreenshot = pyautogui.screenshot() file_name = asksaveasfilename(confirmoverwrite=False,defaultextension='.png') myScreenshot.save(file_name) sys.exit(0) root = tk.Tk() root.title("Screen Recorder") root.geometry("600x220") root.configure(background = '#e6e5e5') frame = tk.Frame(root,bg = '#e6e5e5',pady = 1, width =550, height = 50) frame.grid(row=0,column=0) frame.pack() label0 = tk.Label(frame,font=('Comic Sans MS',26,'bold'),text = " Screen Recorder ",bg= '#663300',fg='white',justify ="center") label0.pack(side=tk.TOP) button =tk.Button(frame, font=('arial', 20,'bold'), text="Start Recording",padx=2,pady=2, bg="green",fg = "white",command=run) button.pack(side=tk.TOP) button1 =tk.Button(frame, font=('arial', 20,'bold'), text="Take Screenshot",padx=2,pady=2, bg="orange",fg = "white",command=screenshot) button1.pack() root.mainloop()
Method #8:
Required Modules:
pip install mss
pip install numpy
pip install opencv-python
import os import ctypes import cv2 as cv import numpy as np from util import getResolution from mss import mss with mss() as sct: # Gets Screen Resolution user32 = ctypes.windll.user32 user32.SetProcessDPIAware() [width, height] = user32.GetSystemMetrics(0), user32.GetSystemMetrics(1) # Define Video Type codec = cv.VideoWriter_fourcc(*"mp4v") out = cv.VideoWriter("video.mp4", codec, 7, (width, height)) # Live Video Display cv.namedWindow("Live", cv.WINDOW_NORMAL) cv.resizeWindow("Live", 480, 270) # Gets Desired Monitor monitor_number = 1 monitor_data = sct.monitors[monitor_number] # Monitor Data monitor = { "top": monitor_data["top"], "left": monitor_data["left"], "width": width, "height": height, } while True: # Grabs Frame + Converts to Numpy Array + Converts Color frame = np.array(sct.grab(monitor)) out.write(frame) cv.imshow("Live", frame) # Exits if Q is pressed if cv.waitKey(1) == ord('q'): break # Cleanup out.release() cv.destroyAllWindows() os.rename("video.mp4", "recording.mp4")
Method #9:
Required Modules:
pip install pypiwin32
pip install numpy
""" Getting frames: https://towardsdatascience.com/lightning-fast-video-reading-in-python-c1438771c4e6 https://github.com/dmlc/decordFaster video file FPS with cv2.VideoCapture and OpenCVhttps://stackoverflow.com/questions/3586046/fastest-way-to-take-a-screenshot-with-python-on-windows Raster: https://docs.microsoft.com/en-us/windows/win32/gdi/raster-operation-codes https://docs.microsoft.com/en-us/windows/win32/gdi/binary-raster-operations https://docs.microsoft.com/en-us/windows/win32/gdi/ternary-raster-operations https://lazarus-ccr.sourceforge.io/docs/lcl/lclintf/bitblt.html Import Docs pywin32api: http://timgolden.me.uk/pywin32-docs/PyWin32.html https://yiyibooks.cn/__src__/meikunyuan6/pywin32/pywin32/PyWin32/win32api.html win32: http://timgolden.me.uk/pywin32-docs/win32.html win32gui: http://timgolden.me.uk/pywin32-docs/win32gui.html https://yiyibooks.cn/__src__/meikunyuan6/pywin32/pywin32/PyWin32/win32gui.html win32ui: http://timgolden.me.uk/pywin32-docs/win32ui.html https://yiyibooks.cn/__src__/meikunyuan6/pywin32/pywin32/PyWin32/win32ui.html win32con: http://timgolden.me.uk/pywin32-docs/win32console.html Other Docs Windows GDI: https://docs.microsoft.com/en-us/windows/win32/api/_gdi/ """ import time import win32api import win32gui, win32ui, win32con import numpy as np class WindowCapture: # Properties handle = None handle_index = None handle_context = None mem_device_context = None data_bit_map = None raster = None original_window_size = 0 x, y, w, h = 0, 0, 0, 0 # Croppable window size properties def __init__(self, window_name=None, region=None, raster=win32con.SRCCOPY): """ Find the desired window and setup resources to copy and send commands to it. :param window_name: The window name :param region: Optional size for a cropped window :param raster: The method used to copy the original frame """ if window_name is None: self.handle = win32gui.GetDesktopWindow() else: self.handle = win32gui.FindWindow(None, window_name) if not self.handle: raise Exception('Window not found: {}'.format(window_name)) # Original size window_size = win32gui.GetWindowRect(self.handle) self.original_window_size = window_size[0], window_size[1], window_size[2] - window_size[0], window_size[3] - window_size[1] # Set cropped size if applicable. if region is None: self.x, self.y, self.w, self.h = window_size[0], window_size[1], window_size[2] - window_size[0], window_size[3] - window_size[1] else: self.x, self.y, self.w, self.h = region[0], region[1], region[2], region[3] # Set handle properties self.handle_index = win32gui.GetWindowDC(self.handle) self.handle_context = win32ui.CreateDCFromHandle(self.handle_index) self.mem_device_context = self.handle_context.CreateCompatibleDC() self.data_bit_map = win32ui.CreateBitmap() self.data_bit_map.CreateCompatibleBitmap(self.handle_context, self.w, self.h) self.raster = raster def win32api_capture_screenshot(self, pad=0): """ Captures a frame of the desired window and converts it to opencv format """ x, y, w, h = self.x, self.y, self.w, self.h self.mem_device_context.SelectObject(self.data_bit_map) self.mem_device_context.BitBlt((pad, pad), (w, h), self.handle_context, (x, y), self.raster) # Converting the bitmap into something opencv can read signed_ints_array = self.data_bit_map.GetBitmapBits(True) img = np.fromstring(signed_ints_array, dtype='uint8') img.shape = (h, w, 4) return img def release_objects(self): """ Releases the objects from memory. Call this when finished capturing the window. """ self.handle_context.DeleteDC() self.mem_device_context.DeleteDC() win32gui.ReleaseDC(self.handle, self.handle_index) win32gui.DeleteObject(self.data_bit_map.GetHandle()) def get_mouse_pos(self): x, y, w, h = self.original_window_size pos = win32gui.GetCursorPos() _x = round(pos[0] / w, 2) _y = round(pos[1] / h, 2) return pos, (_x, _y) def set_mouse_position(self, x, y): w, h = self.original_window_size[2], self.original_window_size[3] win32api.SetCursorPos((int(w*x), int(h*y))) def foreground_send_click(self, x, y, click_type="left"): """ Sends click events to the foreground window """ w, h = self.original_window_size[2], self.original_window_size[3] win32api.mouse_event(win32con.MOUSEEVENTF_MOVE | win32con.MOUSEEVENTF_ABSOLUTE, int(x / w * 65535.0), int(y / h * 65535.0)) if click_type == "left": win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0) elif click_type == "ctrl+left": win32api.keybd_event(win32con.VK_CONTROL, 0, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTDOWN, x, y, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_LEFTUP, x, y, 0, 0) win32api.keybd_event(win32con.VK_CONTROL, 0, win32con.KEYEVENTF_KEYUP, 0) else: win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTDOWN, x, y, 0, 0) win32api.mouse_event(win32con.MOUSEEVENTF_RIGHTUP, x, y, 0, 0) def foreground_scroll(self, scroll_amount, x=0, y=0): """ Sends scroll events to the foreground window """ w, h = self.original_window_size[2], self.original_window_size[3] win32api.mouse_event(win32con.MOUSEEVENTF_MOVE | win32con.MOUSEEVENTF_ABSOLUTE, int(x / w * 65535.0), int(y / h * 65535.0)) direction = 1 if scroll_amount > 0 else -1 ticks = 0 while ticks < abs(scroll_amount): win32api.mouse_event(win32con.MOUSEEVENTF_WHEEL, x, y, direction, 0) ticks += 1 @staticmethod def print_window_names(): """ Prints the names of all the avaliable windows """ def win_enum_handler(handle, ex): if win32gui.IsWindowVisible(handle): print(hex(handle), win32gui.GetWindowText(handle)) win32gui.EnumWindows(win_enum_handler, None) @staticmethod def foreground_send_chars(chars): """ https://devblogs.microsoft.com/oldnewthing/20050530-11/?p=35513 https://stackoverflow.com/questions/31713835/win32apis-keybd-event-function-problems """ string = str(chars) for char in string: win32api.keybd_event(ord(char), 0, 0, 0) time.sleep(.1) win32api.keybd_event(ord(char), 0, win32con.KEYEVENTF_KEYUP, 0) time.sleep(0.2)
Method #10:
Required Modules:
pip install moviepy
pip install numpy
pip install PyAudio
pip install opencv-python
from tkinter import * import threading from pyautogui import screenshot import numpy as np import cv2 import pyaudio import wave import os from moviepy.editor import * # Video video_recording = True fourcc = cv2.VideoWriter_fourcc(*'XVID') videoWriter = None def start_video_recording(): global videoWriter videoWriter = cv2.VideoWriter('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\video.avi', fourcc, 20, (1366, 768)) while video_recording: img = np.array(screenshot()) img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) videoWriter.write(img) img = cv2.resize(img, (int(img.shape[1]/1.3), int(img.shape[0]/1.3))) cv2.waitKey(1) cv2.destroyAllWindows() def stop_video_recording(): global video_recording video_recording = False videoWriter.release() # Audio # Constants chunk = 1024 sample_format = pyaudio.paInt16 channels = 2 fs = 48000 p = None stream = None frames = None audio_recording = True def start_audio_recording(): global p, stream, frames p = pyaudio.PyAudio() stream = p.open(format=sample_format,channels=channels,rate=fs,frames_per_buffer=chunk,input=True) frames = [] while audio_recording: data = stream.read(chunk) frames.append(data) def stop_audio_recording(): global audio_recording, p, stream, frames audio_recording = False put_into_file() def put_into_file(): stream.stop_stream() stream.close() p.terminate() wf = wave.open('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\audio.wav', 'wb') wf.setnchannels(channels) wf.setsampwidth(p.get_sample_size(sample_format)) wf.setframerate(fs) wf.writeframes(b''.join(frames)) wf.close() # Combining audio and video def combine(): videoclip = VideoFileClip("C:\\Users\\Aprameya\\AppData\\Local\\Temp\\video.avi") audioclip = AudioFileClip("C:\\Users\\Aprameya\\AppData\\Local\\Temp\\audio.wav") new_audioclip = CompositeAudioClip([audioclip]) videoclip.audio = new_audioclip videoclip.write_videofile("C:\\Users\\Aprameya\\AppData\\Local\\Temp\\output.mp4") def ask_to_save_file(): from tkinter import filedialog filepath = filedialog.asksaveasfilename(title='Save Recording', filetypes=(('MP4 File', '*.mp4'),)) if filepath.endswith('.mp4'): pass else: filepath = filepath + '.mp4' file = open(filepath, 'wb') outpath = 'C:\\Users\\Aprameya\\AppData\\Local\\Temp\\output.mp4' out = open(outpath, 'rb') outcont = out.read() file.write(outcont) file.close() out.close() # Main Program root = Tk() root.title('Screen Recorder') root.geometry('400x250') def start_recording(): stop_recording_button['state'] = NORMAL threading.Thread(target=start_video_recording).start() threading.Thread(target=start_audio_recording).start() label.config(text='Recording...') def stop_recording(): stop_video_recording() stop_audio_recording() stop_recording_button['state'] = DISABLED label.config(text='Finished Recording!') try: os.remove('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\output.mp4') except: pass combine() ask_to_save_file() try: os.remove('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\video.avi') os.remove('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\audio.wav') os.remove('C:\\Users\\Aprameya\\AppData\\Local\\Temp\\output.mp4') except: pass root.destroy() exit() start_recording_button = Button(root, text='Start Recording', font=('Comic Sans Ms', 15), fg='green', borderwidth=5, command=start_recording) start_recording_button.pack() stop_recording_button = Button(root, text='Stop Recording', font=('Comic Sans Ms', 15), fg='red', state=DISABLED, borderwidth=5, command=stop_recording) stop_recording_button.pack() label = Label(root) label.pack() root.mainloop()
Conclusion:
This post is a great place to start if you want to record a specific window on your computer.We know that sometimes it can be tricky when you want to record your computer screen but don’t know how to do it. We are here to tell you that it is possible by using python.A way to record your computer or pc screen using Python. Many people find this to be a useful tool as they can record a specific window and save the video to share online. Screen recorders are an effective way to record your computer screen, but they can be hard to use and complicated. Our blog post will highlight some of the more popular screen recorders and show you how they work. Python is a programming language that is a leader in terms of popularity, and is used in many different fields including web development, game development, data analysis, and scientific computing. This python screen recorder can be run on Windows, Mac, or Linux, and is the easiest screen recorder on the market to use. You can record your computer or laptop screen with just a few clicks. There is a built-in option to automatically save the video when you are done recording and to upload the video to youtube. This simple python program will allow you to record your screen and we hope that you find this helpful.