que erro é esse:

Traceback (most recent call last):
  File "C:\Users\Wendel\Desktop\Pasta_teste2\JuntadorVideos6_NVIDEA_02.py", line 113, in <module>
    app = VideoCombinerApp(root)
          ^^^^^^^^^^^^^^^^^^^^^^
TypeError: VideoCombinerApp() takes no arguments
Pressione qualquer tecla para continuar. . .

esse é meu codigo:

import tkinter as tk
from tkinter import filedialog, messagebox
from moviepy.editor import VideoFileClip, concatenate_videoclips
from moviepy.video.fx.all import fadein, fadeout
import os
import subprocess

class VideoCombinerApp:
    def init(self, root):
        self.root = root
        self.root.title("Video Combiner")

        self.ad_video_path = None
        self.main_video_paths = []
        self.output_dir = None
        self.use_gpu = self.check_gpu()

        self.create_widgets()

    def create_widgets(self):
        self.label = tk.Label(self.root, text="Selecione o vídeo de anúncio e os vídeos principais")
        self.label.pack(pady=10)

        self.ad_button = tk.Button(self.root, text="Selecionar Vídeo de Anúncio", command=self.select_ad_video)
        self.ad_button.pack(pady=5)

        self.main_button = tk.Button(self.root, text="Selecionar Vídeos Principais", command=self.select_main_videos)
        self.main_button.pack(pady=5)

        self.output_button = tk.Button(self.root, text="Selecionar Diretório de Saída", command=self.select_output_dir)
        self.output_button.pack(pady=5)

        self.combine_button = tk.Button(self.root, text="Combinar Vídeos", command=self.combine_videos)
        self.combine_button.pack(pady=20)

    def select_ad_video(self):
        self.ad_video_path = filedialog.askopenfilename(title="Selecione o Vídeo de Anúncio",
                                                        filetypes=[("Video Files", "*.mp4 *.avi .mov")])
        if self.ad_video_path:
            messagebox.showinfo("Vídeo de Anúncio Selecionado", f"Vídeo de Anúncio:\n{self.ad_video_path}")

    def select_main_videos(self):
        selected_paths = filedialog.askopenfilenames(title="Selecione os Vídeos Principais",
                                                     filetypes=[("Video Files", ".mp4 *.avi *.mov")])
        if selected_paths:
            self.main_video_paths = list(selected_paths)
            messagebox.showinfo("Vídeos Principais Selecionados", f"{len(self.main_video_paths)} vídeos principais selecionados.")

    def select_output_dir(self):
        self.output_dir = filedialog.askdirectory(title="Selecionar pasta para salvar os vídeos combinados")
        if self.output_dir:
            messagebox.showinfo("Diretório de Saída Selecionado", f"Os vídeos combinados serão salvos em:\n{self.output_dir}")

    def check_gpu(self):
        try:
            result = subprocess.run(['ffmpeg', '-encoders'], capture_output=True, text=True)
            if 'h264_nvenc' in result.stdout:
                return True
        except Exception as e:
            print(f"Erro ao verificar GPU: {e}")
        return False

    def process_video_pair(self, ad_clip, main_video_path, index):
        main_clip = VideoFileClip(main_video_path).resize(height=ad_clip.h)
        main_clip = fadein(main_clip, duration=1)

        if index == len(self.main_video_paths) - 1:
            main_clip = fadeout(main_clip, duration=1)

        final_clip = concatenate_videoclips([ad_clip, main_clip], method="compose")

        # Preserva o nome do vídeo principal e adiciona um sufixo
        main_video_name = os.path.basename(main_video_path)
        main_video_name_without_ext, ext = os.path.splitext(main_video_name)
        output_filename = f"{main_video_name_without_ext}_combined{ext}"
        output_path = os.path.join(self.output_dir, output_filename)

        # Escolhe o codec e a configuração com base na disponibilidade da GPU
        if self.use_gpu:
            codec = 'h264_nvenc'
            bitrate = None  # Deixe ffmpeg escolher a melhor configuração
        else:
            codec = 'libx264'
            bitrate = '3000k'

        final_clip.write_videofile(output_path, codec=codec, bitrate=bitrate, preset="slow", threads=4)
        return output_path

    def combine_videos(self):
        if not self.ad_video_path:
            messagebox.showerror("Erro", "Por favor, selecione um vídeo de anúncio.")
            return
        if not self.main_video_paths:
            messagebox.showerror("Erro", "Por favor, selecione pelo menos um vídeo principal.")
            return
        if not self.output_dir:
            messagebox.showerror("Erro", "Por favor, selecione um diretório para salvar os vídeos combinados.")
            return

        try:
            ad_clip = VideoFileClip(self.ad_video_path)

            for i, path in enumerate(self.main_video_paths):
                result = self.process_video_pair(ad_clip, path, i)
                print(f"Vídeo combinado salvo em: {result}")

            messagebox.showinfo("Sucesso", f"Vídeos combinados salvos em:\n{self.output_dir}")
        except Exception as e:
            messagebox.showerror("Erro", f"Ocorreu um erro ao combinar os vídeos: {e}")

if __name__ == "__main__":
    root = tk.Tk()
    app = VideoCombinerApp(root)
    root.mainloop()