Upload ui_form.py

ui_form.py

@@ -0,0 +1,386 @@
+import os
+try:
+    from PyQt5 import QtCore, QtGui, QtWidgets
+except:
+    os.system("pip install PyQt5")
+    os.system("pip install DateTime")
+    os.system("pip install requests")
+from PyQt5 import QtCore, QtGui, QtWidgets
+import sys
+import subprocess
+import threading
+from datetime import datetime
+# from api import API
+import base64
+import requests
+import time
+import json
+
+now = datetime.now().strftime("%Y%m%d%H%M%S")
+
+class Ui_Tool(QtCore.QObject):
+    console_signal = QtCore.pyqtSignal(str)
+    def setupUi(self, Tool):
+        Tool.setObjectName("Tool")
+        Tool.resize(900, 500)
+        Tool.setMaximumSize(QtCore.QSize(900, 500))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(10)
+        Tool.setFont(font)
+        self.centralwidget = QtWidgets.QWidget(parent=Tool)
+        self.centralwidget.setObjectName("centralwidget")
+        self.by = QtWidgets.QLabel(parent=self.centralwidget)
+        self.by.setGeometry(QtCore.QRect(740, 460, 131, 21))
+        self.by.setObjectName("by")
+        self.start_hls = QtWidgets.QPushButton(parent=self.centralwidget)
+        self.start_hls.setGeometry(QtCore.QRect(470, 340, 91, 41))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(10)
+        self.start_hls.setFont(font)
+        self.start_hls.setObjectName("start_hls")
+        self.input_file = QtWidgets.QToolButton(parent=self.centralwidget)
+        self.input_file.setGeometry(QtCore.QRect(470, 150, 91, 41))
+        self.input_file.setObjectName("input_file")
+        self.output_file = QtWidgets.QToolButton(parent=self.centralwidget)
+        self.output_file.setGeometry(QtCore.QRect(470, 210, 91, 41))
+        self.output_file.setObjectName("output_file")
+        self.console_output = QtWidgets.QPlainTextEdit(parent=self.centralwidget)
+        self.console_output.setGeometry(QtCore.QRect(20, 20, 391, 461))
+        self.console_output.setObjectName("console_output")
+        self.console_output.setReadOnly(True)
+        self.input_path_file = QtWidgets.QLineEdit(parent=self.centralwidget)
+        self.input_path_file.setGeometry(QtCore.QRect(580, 150, 151, 41))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(7)
+        self.input_path_file.setFont(font)
+        self.input_path_file.setObjectName("input_path_file")
+        self.output_path_file = QtWidgets.QLineEdit(parent=self.centralwidget)
+        self.output_path_file.setGeometry(QtCore.QRect(580, 210, 151, 41))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(7)
+        self.output_path_file.setFont(font)
+        self.output_path_file.setObjectName("output_path_file")
+        self.start_upload = QtWidgets.QPushButton(parent=self.centralwidget)
+        self.start_upload.setGeometry(QtCore.QRect(470, 410, 91, 41))
+        font = QtGui.QFont()
+        font.setFamily("Times New Roman")
+        font.setPointSize(10)
+        self.start_upload.setFont(font)
+        self.start_upload.setObjectName("start_upload")
+        self.api = QtWidgets.QComboBox(parent=self.centralwidget)
+        self.api.setGeometry(QtCore.QRect(580, 280, 131, 41))
+        self.api.setObjectName("api")
+        self.api.addItem("")
+        self.api.addItem("")
+        self.input_cookie = QtWidgets.QToolButton(parent=self.centralwidget)
+        self.input_cookie.setGeometry(QtCore.QRect(470, 90, 91, 41))
+        self.input_cookie.setObjectName("input_cookie")
+        self.input_path_cookie = QtWidgets.QLineEdit(parent=self.centralwidget)
+        self.input_path_cookie.setGeometry(QtCore.QRect(580, 90, 291, 41))
+        self.input_path_cookie.setObjectName("input_path_cookie")
+        self.input_key = QtWidgets.QLineEdit(parent=self.centralwidget)
+        self.input_key.setGeometry(QtCore.QRect(580, 30, 291, 41))
+        self.input_key.setObjectName("input_key")
+        self.label = QtWidgets.QLabel(parent=self.centralwidget)
+        self.label.setGeometry(QtCore.QRect(500, 30, 31, 41))
+        self.label.setObjectName("label")
+        self.time = QtWidgets.QSpinBox(parent=self.centralwidget)
+        self.time.setGeometry(QtCore.QRect(470, 280, 91, 41))
+        self.time.setMinimum(0)
+        self.time.setObjectName("time")
+        Tool.setCentralWidget(self.centralwidget)
+
+        self.retranslateUi(Tool)
+        self.connect_signals()
+        QtCore.QMetaObject.connectSlotsByName(Tool)
+
+    def retranslateUi(self, Tool):
+        _translate = QtCore.QCoreApplication.translate
+        Tool.setWindowTitle(_translate("Tool", "Tool V1.0.0"))
+        self.by.setText(_translate("Tool", "telegram: pqc2304"))
+        self.start_hls.setText(_translate("Tool", "Start HLS"))
+        self.input_file.setText(_translate("Tool", "Input file"))
+        self.output_file.setText(_translate("Tool", "Output file"))
+        self.start_upload.setText(_translate("Tool", "Start Upload"))
+        self.api.setItemText(0, _translate("Tool", "TikTok V1"))
+        self.api.setItemText(1, _translate("Tool", "Google V1"))
+        self.input_cookie.setText(_translate("Tool", "Cookie"))
+        self.label.setText(_translate("Tool", "Key"))
+
+    def connect_signals(self):
+        """Connect button clicks and signals"""
+        self.input_file.clicked.connect(self.select_input_file)
+        self.output_file.clicked.connect(self.select_output_folder)
+        self.start_hls.clicked.connect(self.start_hls_conversion)
+        self.start_upload.clicked.connect(self.start_upload_process)
+        self.input_cookie.clicked.connect(self.select_input_cookie)
+        self.console_signal.connect(self.update_console)
+
+    @QtCore.pyqtSlot(str)
+    def update_console(self, message):
+        self.console_output.appendPlainText(message)
+
+    def log_to_console(self, message):
+        self.console_signal.emit(f"{message}")
+
+    def select_input_cookie(self):
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            None, "Select File Cookie", "",
+            "Cookie Files (*.txt);;All Files (*)"
+        )
+        if file_path:
+            self.input_path_cookie.setText(base64.b64encode(open(file_path, "r").read().encode('utf-8')).decode('utf-8'))
+            self.log_to_console(f"Selected input file: {file_path}")
+
+    def select_input_file(self):
+        file_path, _ = QtWidgets.QFileDialog.getOpenFileName(
+            None, "Select Video File", "",
+            "Video Files (*.mp4 *.avi *.mkv *.mov);;All Files (*)"
+        )
+        if file_path:
+            self.input_path_file.setText(file_path)
+            self.log_to_console(f"Selected input file: {file_path}")
+
+    def select_output_folder(self):
+        folder_path = QtWidgets.QFileDialog.getExistingDirectory(
+            None, "Select Output Folder"
+        )
+        if folder_path:
+            self.output_path_file.setText(folder_path)
+            self.log_to_console(f"Selected output folder: {folder_path}")
+
+    def start_hls_conversion(self):
+        # now = datetime.now().strftime("%Y%m%d%H%M%S")
+        input_file = self.input_path_file.text()
+        output_folder = self.output_path_file.text()
+
+        if not input_file or not output_folder:
+            self.log_to_console("\n⚠️ Error: Please select both input file and output folder")
+            return
+
+        if not os.path.exists(input_file):
+            self.log_to_console("\n⚠️ Error: Input file does not exist")
+            return
+
+        thread = threading.Thread(target=self.run_ffmpeg_hls, args=(input_file, output_folder))
+        thread.start()
+        self.log_to_console("---Started HLS conversion...")
+
+    def get_bitrate(self,file_path):
+        cmd = [
+            "ffprobe",
+            "-v", "error",
+            "-select_streams", "v:0",
+            "-show_entries", "stream=bit_rate",
+            "-of", "default=noprint_wrappers=1:nokey=1",
+            file_path
+        ]
+        
+        try:
+            result = subprocess.run(cmd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+            bitrate = result.stdout.decode().strip()
+            if not bitrate or "N/A" in bitrate:
+                return "5000k"
+            return f"{int(bitrate) // 5000}k"
+        except subprocess.CalledProcessError:
+            return "5000k"
+
+    def compress_ts_file(self,file_path,output_folder):
+        file_size = os.path.getsize(file_path)
+        MAX_SIZE = 9000000
+        if file_size > MAX_SIZE:
+            self.log_to_console(f"File {file_path} ({file_size} bytes) vượt 9MB, đang nén lại...")
+            
+            bitrate = self.get_bitrate(file_path)
+            
+            dir_name = os.path.dirname(file_path)
+            base_name = os.path.basename(file_path)
+            temp_file = f"{output_folder}/temp_{base_name}"
+            
+            cmd = [
+                "ffmpeg",
+                "-i", file_path,
+                "-c:v", "libx264",
+                "-b:v", bitrate,
+                "-minrate", bitrate,
+                "-maxrate", bitrate,
+                "-bufsize", "2M",
+                "-preset", "ultrafast",
+                "-c:a", "copy",
+                "-f", "mpegts",
+                temp_file
+            ]
+            
+            try:
+                subprocess.run(cmd, check=True, stderr=subprocess.PIPE)
+                new_size = os.path.getsize(temp_file)
+                self.log_to_console(f"⚠️Kích thước sau nén: {new_size} bytes")
+                
+                # Kiểm tra xem file nén có nhỏ hơn 10MB không
+                if new_size > MAX_SIZE:
+                    self.log_to_console(f"⚠️File {temp_file} vẫn vượt 9MB ({new_size} bytes), thử nén mạnh hơn...")
+                    cmd = [
+                        "ffmpeg",
+                        "-i", file_path,
+                        "-c:v", "libx264",
+                        "-b:v", bitrate,
+                        "-preset", "medium",
+                        "-c:a", "copy",
+                        "-f", "mpegts",
+                        temp_file
+                    ]
+                    subprocess.run(cmd, check=True, stderr=subprocess.PIPE)
+                    new_size = os.path.getsize(temp_file)
+                    self.log_to_console(f"⚠️Kích thước sau nén lần 2: {new_size} bytes")
+                
+                # Thay thế file gốc nếu nén thành công
+                if new_size <= MAX_SIZE:
+                    os.replace(temp_file, file_path)
+                    self.log_to_console(f"⚠️Đã nén {file_path} xuống {new_size} bytes.")
+                else:
+                    self.log_to_console(f"⚠️Không thể nén {file_path} xuống dưới 9MB với bitrate hiện tại.")
+                    os.remove(temp_file)
+            except subprocess.CalledProcessError as e:
+                self.log_to_console(f"⚠️Lỗi khi nén file {file_path}: {e.stderr.decode()}")
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+        else:
+            self.log_to_console(f"✅File {file_path} ({file_size} bytes) dưới 9MB, không cần nén.")
+
+
+    def run_ffmpeg_hls(self, input_file, output_folder):
+        try:
+            print(self.time.text())
+            
+            output_playlist = os.path.join(output_folder, f"{now}.m3u8")
+            # ffmpeg_cmd = [
+            #     "ffmpeg",
+            #     "-i", input_file,
+            #     "-c:v", "libx264",
+            #     "-c:a", "aac",
+            #     "-f", "hls",
+            #     "-hls_time", self.time.text(),
+            #     "-hls_list_size", "0",
+            #     "-hls_segment_filename", os.path.join(output_folder, now+"00%d.ts"),
+            #     output_playlist
+            # ]
+
+            ffmpeg_cmd = [
+                "ffmpeg", '-hwaccel', 'cuda', '-i', input_file,
+                '-c:v', 'h264_nvenc', '-preset', 'p4', '-b:v', '5M',
+                '-c:a', 'aac', '-b:a', '128k', '-ac', '2',
+                '-hls_time', self.time.text(),
+                '-hls_playlist_type', 'vod',
+                '-hls_segment_type', 'mpegts',
+                '-hls_flags', 'independent_segments+split_by_time',
+                "-hls_segment_filename", os.path.join(output_folder, now+"00%d.ts"),
+                '-force_key_frames', f"expr:gte(t,n_forced*"+self.time.text()+")",
+                '-map', '0:v:0', '-map', '0:a:0',
+                '-gpu', '0',
+                output_playlist
+            ]
+
+            process = subprocess.Popen(
+                ffmpeg_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                universal_newlines=True
+            )
+
+            while True:
+                output = process.stderr.readline()
+                if output == '' and process.poll() is not None:
+                    break
+                if output:
+                    self.log_to_console(output.strip())
+
+            if process.returncode == 0:
+                self.log_to_console("\n✅ HLS conversion completed successfully")
+                self.log_to_console("\n✅ HLS start check ts MB")
+                for file in os.listdir(output_folder):
+                    if file.endswith(".ts"):
+                        self.compress_ts_file(f"{output_folder}/{file}",output_folder)
+                self.log_to_console("\n✅ HLS start check ts MB completed successfully")
+            else:
+                self.log_to_console("\n⚠️ HLS conversion failed")
+
+        except Exception as e:
+            self.log_to_console(f"\n⚠️ Error during HLS conversion: {str(e)}")
+
+    def start_upload_process(self):
+        input_file = self.input_path_file.text()
+        output_folder = self.output_path_file.text()
+
+        if not input_file or not output_folder:
+            self.log_to_console("\n⚠️ Error: Please select both input file and output folder")
+            return
+
+        self.log_to_console("---Starting upload process...")
+        thread = threading.Thread(target=self.upload_file, args=(output_folder,))
+        thread.start()
+
+    def upload_file(self, output_folder):
+        cookie = self.input_path_cookie.text()
+        api = self.api.currentText()
+        key = self.input_key.text()
+        if api == 'TikTok V1':
+            url_api = f"https://https://upload-v2.cuong.one/?key={key}&cookie={cookie}"
+        elif api == "Google V1":
+            url_api = f"https://upload-lh3.cuong.shop/?key={key}"
+        data_list = open(f'{now}.json', 'w')
+        # api = API.TikTok(cookie=cookie)
+        data_list = [f for f in os.listdir(output_folder) if f.endswith('.ts')]
+        len_str = len(data_list)
+        data = {}
+        s = 0
+        for i in data_list:
+            s += 1
+            if i in data and data[i] == "":
+                continue
+            try:
+                # upload = api.main(f'{output_folder}/{i}')
+                files = {
+                    'file': open(f'{output_folder}/{i}', 'rb').read(),
+                    "time":int(time.time()) 
+                }
+                upload = requests.post(url_api, files=files).json()['url']
+                data[i] = upload
+                open('data.txt', 'a+').write(f'{upload}\n')
+                self.log_to_console(f'{s}/{len_str}')
+                # self.log_to_console(upload)
+            except Exception as e:
+                data[i] = ""
+                self.log_to_console(f"\n⚠️Upload failed: {str(e)}")
+            with open(f'{now}.json', 'w', encoding="utf-8") as f:
+                json.dump(data, f, indent=4, ensure_ascii=False)
+        self.log_to_console("\n✅Upload completed successfully")
+        with open(f'{output_folder}/{now}.m3u8', 'r', encoding='utf-8') as file:
+            file_m3u8 = file.read()
+
+        with open(f'{now}.json', 'r', encoding='utf-8') as file:
+            data_list = json.loads(file.read())
+
+        with open(f'{now}.m3u8', 'w', encoding='utf-8') as output_file:
+            data = file_m3u8
+            for key, value in data_list.items():
+                data = data.replace(key, value)
+            
+            output_file.write(data)
+            # print(data)
+        self.log_to_console("\nReplace m3u8 successfully")
+
+
+
+
+if __name__ == "__main__":
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    Tool = QtWidgets.QMainWindow()
+    ui = Ui_Tool()
+    ui.setupUi(Tool)
+    Tool.show()
+    sys.exit(app.exec())