Использование DarkScreen

import sys
import os
import cv2
import numpy as np
from datetime import datetime
from PyQt5.QtWidgets import QApplication, QMainWindow, QPushButton, QVBoxLayout, QWidget, QLabel, QCheckBox, QProgressBar
from PyQt5.QtCore import QTimer, Qt, QTime, QThread, pyqtSignal
from PyQt5.QtGui import QFont, QPalette, QColor, QIcon
import subprocess

class VideoCompressor(QThread):
    progress = pyqtSignal(int)
    finished = pyqtSignal()

    def __init__(self, input_file, output_file):
        super().__init__()
        self.input_file = input_file
        self.output_file = output_file
        self.process = None

    def run(self):
        try:
            command = [
                'ffmpeg',
                '-i', self.input_file,
                '-vcodec', 'libx264',
                '-preset', 'slow',  # Better compression
                '-crf', '22',  # Adjusted for better size/quality balance
                self.output_file
            ]

            self.process = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, universal_newlines=True, creationflags=subprocess.CREATE_NO_WINDOW)

            total_duration = None
            for line in self.process.stdout:
                if 'Duration' in line:
                    total_duration = self.parse_duration(line)
                if 'time=' in line:
                    current_time = self.parse_time(line)
                    if total_duration and current_time:
                        progress = int((current_time / total_duration) * 100)
                        self.progress.emit(progress)

            self.process.wait()
            self.finished.emit()

        except Exception as e:
            print(f"Error during video compression: {e}")
            self.finished.emit()

    def parse_duration(self, line):
        try:
            duration_str = line.split('Duration: ')[1].split(',')[0]
            return self.time_str_to_seconds(duration_str)
        except Exception:
            return None

    def parse_time(self, line):
        try:
            time_str = line.split('time=')[1].split(' ')[0]
            return self.time_str_to_seconds(time_str)
        except Exception:
            return None

    def time_str_to_seconds(self, time_str):
        h, m, s = map(float, time_str.split(':'))
        return h * 3600 + m * 60 + s

    def terminate(self):
        if self.process:
            self.process.terminate()
            self.process = None
        super().terminate()

class ScreenRecorder(QMainWindow):
    def __init__(self):
        super().__init__()

        self.initUI()

        self.recording = False
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.record_frame)
        self.time_elapsed = QTime(0, 0)
        
        self.blur_screen = False
        self.frame_count = 0
        self.video_writer = None
        self.compressor = None

    def initUI(self):
        self.setGeometry(100, 100, 250, 250)
        self.setFixedSize(250, 250)  # Фиксированный размер окна
        self.setWindowTitle('Screen Recorder')
        self.setWindowIcon(QIcon('my_icon.ico'))  # Установка иконки

        # Установим темный фон
        palette = QPalette()
        palette.setColor(QPalette.Window, QColor(30, 30, 30))
        palette.setColor(QPalette.WindowText, Qt.white)
        palette.setColor(QPalette.Button, QColor(50, 50, 50))
        palette.setColor(QPalette.ButtonText, Qt.white)
        self.setPalette(palette)

        self.title_label = QLabel('Screen Recorder', self)
        self.title_label.setAlignment(Qt.AlignCenter)
        self.title_label.setFont(QFont("Arial", 14))
        self.title_label.setStyleSheet("color: white;")

        self.timer_label = QLabel('00:00', self)
        self.timer_label.setAlignment(Qt.AlignCenter)
        self.timer_label.setFont(QFont("Arial", 16))
        self.timer_label.setStyleSheet("color: white;")

        self.record_button = QPushButton('Start Recording', self)
        self.record_button.clicked.connect(self.toggle_recording)
        self.record_button.setStyleSheet("background-color: green; color: white; font-size: 14px;")

        self.blur_button = QPushButton('Enable Blur Screen', self)
        self.blur_button.clicked.connect(self.toggle_blur)
        self.blur_button.setEnabled(False)
        self.blur_button.setStyleSheet("background-color: green; color: white; font-size: 14px;")

        self.always_on_top_checkbox = QCheckBox("Always on Top", self)
        self.always_on_top_checkbox.setChecked(True)
        self.always_on_top_checkbox.stateChanged.connect(self.toggle_always_on_top)
        self.always_on_top_checkbox.setStyleSheet("color: white; font-size: 14px;")

        self.progress_bar = QProgressBar(self)
        self.progress_bar.setValue(0)
        self.progress_bar.setVisible(False)

        layout = QVBoxLayout()
        layout.addWidget(self.title_label)
        layout.addWidget(self.timer_label)

        button_layout = QVBoxLayout()
        button_layout.addWidget(self.record_button)
        button_layout.addWidget(self.blur_button)
        button_layout.addWidget(self.always_on_top_checkbox)
        button_layout.addWidget(self.progress_bar)

        layout.addLayout(button_layout)

        container = QWidget()
        container.setLayout(layout)
        self.setCentralWidget(container)
        
        # Set the window to be always on top by default
        self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)
        self.show()

    def closeEvent(self, event):
        if self.recording:
            self.stop_recording()
        if self.compressor and self.compressor.isRunning():
            self.compressor.terminate()
        event.accept()

    def toggle_recording(self):
        if self.recording:
            self.stop_recording()
        else:
            self.start_recording()

    def start_recording(self):
        self.recording = True
        self.record_button.setText('Stop Recording')
        self.record_button.setStyleSheet("background-color: red; color: white; font-size: 14px;")
        self.blur_button.setEnabled(True)
        self.frame_count = 0
        self.time_elapsed.start()

        # Initialize video writer
        screen = QApplication.primaryScreen()
        screenshot = screen.grabWindow(0).toImage()
        image = self.convert_qimage_to_cv2(screenshot)
        height, width, _ = image.shape

        current_time = datetime.now().strftime('%d%m%Y%H%M%S')
        self.output_file = os.path.join(os.path.expanduser("~"), "Desktop", f'{current_time}.avi')
        self.compressed_file = os.path.join(os.path.expanduser("~"), "Desktop", f'{current_time}.mp4')
        
        self.video_writer = cv2.VideoWriter(self.output_file, cv2.VideoWriter_fourcc(*'MJPG'), 30, (width, height), True)
        
        if not self.video_writer.isOpened():
            print("Error: Could not open video writer")
            return

        self.timer.start(30)  # 30 ms for ~33 FPS
        print("Recording started")

    def stop_recording(self):
        self.recording = False
        self.record_button.setText('Start Recording')
        self.record_button.setStyleSheet("background-color: green; color: white; font-size: 14px;")
        self.blur_button.setEnabled(False)
        self.timer.stop()

        # Release video writer
        if self.video_writer:
            self.video_writer.release()
            self.video_writer = None
        print(f"Video saved as {self.output_file}")

        # Compress video using ffmpeg
        self.progress_bar.setVisible(True)
        self.compressor = VideoCompressor(self.output_file, self.compressed_file)
        self.compressor.progress.connect(self.update_progress)
        self.compressor.finished.connect(self.compression_finished)
        self.compressor.start()
        print("Recording stopped")

    def update_progress(self, value):
        self.progress_bar.setValue(value)

    def compression_finished(self):
        self.progress_bar.setVisible(False)
        print(f"Compressed video saved as {self.compressed_file}")
        # Optionally, delete the original file to save space
        os.remove(self.output_file)

    def toggle_blur(self):
        self.blur_screen = not self.blur_screen
        if self.blur_screen:
            self.blur_button.setText('Disable Blur Screen')
            self.blur_button.setStyleSheet("background-color: red; color: white; font-size: 14px;")
        else:
            self.blur_button.setText('Enable Blur Screen')
            self.blur_button.setStyleSheet("background-color: green; color: white; font-size: 14px;")
        print(f"Blur screen: {self.blur_screen}")

    def toggle_always_on_top(self):
        if self.always_on_top_checkbox.isChecked():
            self.setWindowFlags(self.windowFlags() | Qt.WindowStaysOnTopHint)
        else:
            self.setWindowFlags(self.windowFlags() & ~Qt.WindowStaysOnTopHint)
        self.show()

    def record_frame(self):
        try:
            screen = QApplication.primaryScreen()
            screenshot = screen.grabWindow(0).toImage()
            image = self.convert_qimage_to_cv2(screenshot)

            if self.blur_screen:
                image = cv2.GaussianBlur(image, (65, 65), 0)  # Усиление эффекта размытия

            if self.video_writer:
                self.video_writer.write(image)
            self.frame_count += 1

            # Update timer label
            elapsed_time = self.time_elapsed.elapsed() / 1000
            minutes = int(elapsed_time // 60)
            seconds = int(elapsed_time % 60)
            self.timer_label.setText(f'{minutes:02}:{seconds:02}')
        except Exception as e:
            print(f"Error during frame recording: {e}")

    def convert_qimage_to_cv2(self, qimage):
        try:
            width = qimage.width()
            height = qimage.height()
            ptr = qimage.bits()
            ptr.setsize(qimage.byteCount())
            arr = np.array(ptr).reshape(height, width, 4)  # 4 channels (RGBA)
            return cv2.cvtColor(arr, cv2.COLOR_RGBA2BGR)  # Use BGR to match screen colors
        except Exception as e:
            print(f"Error during QImage to CV2 conversion: {e}")
            return np.zeros((height, width, 3), dtype=np.uint8)

if __name__ == '__main__':
    app = QApplication(sys.argv)
    recorder = ScreenRecorder()
    recorder.show()
    try:
        sys.exit(app.exec_())
    except SystemExit as e:
        print(f"SystemExit: {e}")
    except Exception as e:
        print(f"Exception: {e}")