Skip to content
TheChatArchiveThe Chat Archive
o1-preview-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Seria possível ajustar o script para que ao invés de mostrar apenas 2 frases, mostrar 4…

  1. User

    Seria possível ajustar o script para que ao invés de mostrar apenas 2 frases, mostrar 4 (mas logicamente tem que ser de forma sincronizada e precisa e não ir subindo de forma desordenada e imprecisa)

    Por favor, após ter pensado a fundo passo a passo, envie o código completo com as atualizações necessárias.

    import re
    from datetime import timedelta
    from PIL import Image, ImageDraw, ImageFont, ImageFilter
    import subprocess
    import os
    import multiprocessing
    from functools import lru_cache
    import shutil
    from tqdm import tqdm
    import time
    
    # Configurações
    IMAGE_SIZE = (1920, 1080)
    FONT_COLOR = "#FBF04A"
    HIGHLIGHT_COLOR = "#FF6156"
    OUTLINE_COLOR = "#000000"
    UPPER_CASE = False
    FPS = 30
    FADE_DURATION = 3
    FONT_SIZE_INCOMPLETE = 120
    FONT_SIZE_COMPLETE = 120
    FONT_PATH = r"C:\Users\lucas\Downloads\LilitaOne-Regular.ttf"
    SCROLL_DURATION = 15  # Duração em segundos para a rolagem de cada frase
    
    def hex_to_rgb(hex_color):
        return tuple(int(hex_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
    
    
    def parse_time(time_str):
        match = re.match(r'(\d+):(\d+):(\d+)', time_str)
        if match:
            minutes, seconds, milliseconds = map(int, match.groups())
            return timedelta(minutes=minutes, seconds=seconds, milliseconds=milliseconds)
        return timedelta(0)
    
    
    def get_audio_duration(audio_file):
        command = [
            'ffprobe',
            '-v', 'error',
            '-show_entries', 'format=duration',
            '-of', 'default=noprint_wrappers=1:nokey=1',
            audio_file
        ]
        result = subprocess.run(command, capture_output=True, text=True)
        return float(result.stdout)
    
    
    def read_subtitles(filename):
        subtitles = []
        with open(filename, 'r', encoding='utf-8') as file:
            for line in file:
                match = re.match(r'\[(\d+:\d+:\d+)\] (.+)', line.strip())
                if match:
                    time_str, word = match.groups()
                    subtitles.append((parse_time(time_str), word.upper() if UPPER_CASE else word))
        
        audio_duration = get_audio_duration('audio.wav')
        final_timestamp = timedelta(seconds=audio_duration)
        subtitles.append((final_timestamp, ""))
    
        # Processar legendas em frases completas
        sentences = []
        sentence_words = []
        sentence_start_time = None
        sentence_start_index = None
    
        for i, (time, word) in enumerate(subtitles):
            if word == "":
                continue  # Ignora palavras vazias
            if word[0].isupper() and (i == 0 or subtitles[i - 1][1].endswith('.')):
                # Início de uma nova frase
                if sentence_words:
                    # Adiciona a frase anterior à lista
                    sentences.append({
                        'start_time': sentence_start_time,
                        'end_time': subtitles[i - 1][0],  # Tempo final é o tempo da última palavra
                        'words': sentence_words,
                        'start_index': sentence_start_index,
                        'end_index': i,  # Exclusivo
                    })
                # Inicia nova frase
                sentence_words = [word]
                sentence_start_time = time
                sentence_start_index = i
            else:
                sentence_words.append(word)
        # Adiciona a última frase
        if sentence_words:
            sentences.append({
                'start_time': sentence_start_time,
                'end_time': subtitles[-1][0],
                'words': sentence_words,
                'start_index': sentence_start_index,
                'end_index': len(subtitles),
            })
    
        # Inicializar fonte para calcular tamanhos
        font = ImageFont.truetype(FONT_PATH, FONT_SIZE_COMPLETE)
        space_width = font.getlength(' ')
        line_spacing = 10
        max_width = IMAGE_SIZE[0] - 40
    
        for sentence in sentences:
            lines = arrange_sentence_into_lines(sentence['words'], font, max_width, space_width)
            sentence_height = len(lines) * (FONT_SIZE_COMPLETE + line_spacing)
            sentence['lines'] = lines
            sentence['height'] = sentence_height
    
        return subtitles, sentences
    
    
    @lru_cache(maxsize=1000)
    def create_gradient_word(word, width, height, start_color, end_color, progress, font_size):
        font = ImageFont.truetype(FONT_PATH, font_size)
        ascent, descent = font.getmetrics()
        total_height = ascent + descent
    
        padding = 20
        word_image = Image.new('RGBA', (int(width) + padding, total_height + padding), (0, 0, 0, 0))
        draw = ImageDraw.Draw(word_image)
        
        x, y = padding // 2, ascent
    
        # Desenhar o texto principal sem sombra
        draw.text((x, y), word, font=font, fill=hex_to_rgb(end_color), anchor="ls")
        
        mask = Image.new('L', word_image.size, 0)
        mask_draw = ImageDraw.Draw(mask)
        mask_draw.text((x, y), word, font=font, fill=255, anchor="ls")
        mask = mask.filter(ImageFilter.GaussianBlur(radius=1.0))
        
        gradient = Image.new('RGBA', word_image.size, (0, 0, 0, 0))
        start_color_rgb = hex_to_rgb(start_color)
        end_color_rgb = hex_to_rgb(end_color)
        
        for x_coord in range(word_image.width):
            ratio = max(0, min(1, (x_coord / (width + padding) - progress) / 0.1))
            r = int(start_color_rgb[0] + (end_color_rgb[0] - start_color_rgb[0]) * ratio)
            g = int(start_color_rgb[1] + (end_color_rgb[1] - start_color_rgb[1]) * ratio)
            b = int(start_color_rgb[2] + (end_color_rgb[2] - start_color_rgb[2]) * ratio)
            color = (r, g, b, 255)
            ImageDraw.Draw(gradient).line([(x_coord, 0), (x_coord, word_image.height)], fill=color)
        
        gradient.putalpha(mask)
        
        return Image.alpha_composite(word_image, gradient)
    
    
    def arrange_sentence_into_lines(sentence_words, font, max_width, space_width):
        lines = []
        current_line = []
        current_line_width = 0
        for word in sentence_words:
            word_width = font.getlength(word)
            if current_line_width + word_width + (space_width if current_line else 0) > max_width:
                lines.append(current_line)
                current_line = [word]
                current_line_width = word_width + space_width
            else:
                if current_line:
                    current_line_width += word_width + space_width
                else:
                    current_line_width = word_width
                current_line.append(word)
        if current_line:
            lines.append(current_line)
        return lines
    
    
    def process_frame(frame_index, subtitles, sentences, background_image, num_frames):
        current_time = timedelta(seconds=frame_index / FPS)
        image = background_image.copy()
    
        # Inicializar fonte
        font = ImageFont.truetype(FONT_PATH, FONT_SIZE_COMPLETE)
        space_width = font.getlength(' ')
        line_spacing = 10
        max_width = IMAGE_SIZE[0] - 40
    
        sentences_on_screen = []
    
        # Iterar sobre as frases para encontrar as que devem estar na tela
        for sentence in sentences:
            sentence_start_time = sentence['start_time'] - timedelta(seconds=2)  # Começa 1 segundo antes
            sentence_end_time = sentence_start_time + timedelta(seconds=SCROLL_DURATION)
            if sentence_start_time <= current_time <= sentence_end_time:
                time_since_start = (current_time - sentence_start_time).total_seconds()
                progress = time_since_start / SCROLL_DURATION
                y = IMAGE_SIZE[1] - progress * (IMAGE_SIZE[1] + sentence['height'])
                sentences_on_screen.append((y, sentence))
    
        # Desenhar as frases na tela
        for y, sentence in sentences_on_screen:
            lines = sentence['lines']
            word_index = sentence['start_index']
            current_y = y
    
            for line in lines:
                line_width = sum(font.getlength(word) for word in line) + space_width * (len(line) -1)
                x = (IMAGE_SIZE[0] - line_width) // 2
    
                for word in line:
                    word_time = subtitles[word_index][0]
                    next_word_time = subtitles[word_index + 1][0] if word_index + 1 < len(subtitles) else word_time + timedelta(seconds=2)
    
                    ascent_word, descent_word = font.getmetrics()
                    text_width = font.getlength(word)
                    y_centered = current_y + ascent_word
    
                    # Decidir cor e progresso para destaque
                    if current_time >= next_word_time:
                        color = FONT_COLOR
                        progress_word = 1.0
                    elif current_time >= word_time:
                        word_duration = (next_word_time - word_time).total_seconds()
                        progress_word = min(max((current_time - word_time).total_seconds() / word_duration, 0.0), 1.0)
                        color = FONT_COLOR
                    else:
                        color = HIGHLIGHT_COLOR
                        progress_word = 1.0
    
                    gradient_image = create_gradient_word(word, text_width, FONT_SIZE_COMPLETE, color, HIGHLIGHT_COLOR, progress_word, FONT_SIZE_COMPLETE)
                    image.paste(gradient_image, (int(x -5), int(y_centered - ascent_word -5)), gradient_image)
    
                    x += text_width + space_width
                    word_index +=1
    
                current_y += FONT_SIZE_COMPLETE + line_spacing
    
        # Aplicar fade in e fade out
        if frame_index < FADE_DURATION * FPS:
            fade_opacity = frame_index / (FADE_DURATION * FPS)
            fade_overlay = Image.new('RGBA', image.size, (0, 0, 0, int(255 * (1 - fade_opacity))))
            image = Image.alpha_composite(image.convert('RGBA'), fade_overlay).convert('RGB')
        elif frame_index > num_frames - FADE_DURATION * FPS:
            fade_opacity = (num_frames - frame_index) / (FADE_DURATION * FPS)
            fade_overlay = Image.new('RGBA', image.size, (0, 0, 0, int(255 * (1 - fade_opacity))))
            image = Image.alpha_composite(image.convert('RGBA'), fade_overlay).convert('RGB')
    
        # Converter para RGB para salvar como JPEG
        return image.convert('RGB')
    
    
    def generate_frames_chunk(args):
        start_frame, end_frame, subtitles, sentences, output_dir, background_image, num_frames, progress_queue = args
    
        for frame_index in range(start_frame, end_frame):
            try:
                image = process_frame(frame_index, subtitles, sentences, background_image, num_frames)
                frame_filename = os.path.join(output_dir, f"frame_{frame_index:04d}.jpg")
                image.save(frame_filename, quality=95)
                progress_queue.put(1)
            except Exception as e:
                print(f"Erro ao processar o frame {frame_index}: {str(e)}")
                progress_queue.put(1)  # Ainda incrementamos o progresso para evitar travamentos
    
        return end_frame - start_frame
    
    
    def generate_frames_parallel(subtitles, sentences, output_dir, background_image):
        total_duration = (subtitles[-1][0] + timedelta(seconds=2)).total_seconds()
        num_frames = int(total_duration * FPS) + 1
    
        num_processes = multiprocessing.cpu_count()
        chunk_size = num_frames // num_processes + 1
    
        manager = multiprocessing.Manager()
        progress_queue = manager.Queue()
    
        args_list = [
            (i * chunk_size, min((i + 1) * chunk_size, num_frames), subtitles, sentences, output_dir, background_image, num_frames, progress_queue)
            for i in range(num_processes)
        ]
    
        with multiprocessing.Pool(processes=num_processes) as pool:
            with tqdm(total=num_frames, unit='frame', desc='Gerando frames') as pbar:
                results = pool.map_async(generate_frames_chunk, args_list)
                
                while not results.ready():
                    frames_processed = progress_queue.qsize()
                    if frames_processed > 0:
                        pbar.update(frames_processed)
                        for _ in range(frames_processed):
                            progress_queue.get()
                    time.sleep(0.1)
    
                frames_processed = progress_queue.qsize()
                if frames_processed > 0:
                    pbar.update(frames_processed)
    
        # Verificar se todos os frames foram gerados
        expected_frames = num_frames
        generated_frames = len([f for f in os.listdir(output_dir) if f.endswith('.jpg')])
        if generated_frames < expected_frames:
            print(f"Aviso: Apenas {generated_frames} de {expected_frames} frames foram gerados.")
        else:
            print(f"Todos os {expected_frames} frames foram gerados com sucesso.")
    
    
    def create_video(frame_folder, output_video, audio_file):
        frame_pattern = os.path.join(frame_folder, 'frame_%04d.jpg')
        duration = get_audio_duration(audio_file)
        fade_out_start = duration - FADE_DURATION
    
        command = [
            'ffmpeg',
            '-y',
            '-framerate', str(FPS),
            '-i', frame_pattern,
            '-i', audio_file,
            '-c:v', 'h264_nvenc',
            '-preset', 'medium',
            '-rc', 'vbr_hq',
            '-cq', '23',
            '-b:v', '10M',
            '-maxrate', '20M',
            '-bufsize', '20M',
            '-profile:v', 'high',
            '-c:a', 'aac',
            '-profile:a', 'aac_low',
            '-b:a', '448k',
            '-vf', f"fade=t=in:st=0:d={FADE_DURATION},fade=t=out:st={fade_out_start}:d={FADE_DURATION}",
            '-shortest',
            output_video
        ]
        subprocess.run(command, check=True)
    
    
    def main():
        try:
            subtitles, sentences = read_subtitles('legenda.srt')
            output_dir = 'frames'
            os.makedirs(output_dir, exist_ok=True)
    
            background_image_path = r"C:\Users\lucas\OneDrive\Documentos\capa.jpg"
            background_image = Image.open(background_image_path).convert("RGBA").resize(IMAGE_SIZE)
    
            generate_frames_parallel(subtitles, sentences, output_dir, background_image)
            create_video(output_dir, 'output_video.mp4', 'audio.wav')
            shutil.rmtree(output_dir)
        except Exception as e:
            print(f"Erro durante a execução do programa: {str(e)}")
    
    
    if __name__ == "__main__":
        main()
    
  2. Assistant

    Sim, é possível ajustar o script para mostrar até 4 frases ao invés de 2, mantendo a sincronização precisa e evitando uma movimentação desordenada. Para isso, precisamos modificar a forma como calculamos as posições das frases na função process_frame.

    A seguir, apresento o código completo com as atualizações necessárias:

    import re
    from datetime import timedelta
    from PIL import Image, ImageDraw, ImageFont, ImageFilter
    import subprocess
    import os
    import multiprocessing
    from functools import lru_cache
    import shutil
    from tqdm import tqdm
    import time
    
    # Configurações
    IMAGE_SIZE = (1920, 1080)
    FONT_COLOR = "#FBF04A"
    HIGHLIGHT_COLOR = "#FF6156"
    OUTLINE_COLOR = "#000000"
    UPPER_CASE = False
    FPS = 30
    FADE_DURATION = 3
    FONT_SIZE_INCOMPLETE = 120
    FONT_SIZE_COMPLETE = 120
    FONT_PATH = r"C:\Users\lucas\Downloads\LilitaOne-Regular.ttf"
    SCROLL_DURATION = 15  # Duração em segundos para a rolagem de cada frase
    SPACING_BETWEEN_SENTENCES = 30  # Espaçamento vertical entre frases
    
    def hex_to_rgb(hex_color):
        return tuple(int(hex_color.lstrip('#')[i:i+2], 16) for i in (0, 2, 4))
    
    
    def parse_time(time_str):
        match = re.match(r'(\d+):(\d+):(\d+)', time_str)
        if match:
            minutes, seconds, milliseconds = map(int, match.groups())
            return timedelta(minutes=minutes, seconds=seconds, milliseconds=milliseconds)
        return timedelta(0)
    
    
    def get_audio_duration(audio_file):
        command = [
            'ffprobe',
            '-v', 'error',
            '-show_entries', 'format=duration',
            '-of', 'default=noprint_wrappers=1:nokey=1',
            audio_file
        ]
        result = subprocess.run(command, capture_output=True, text=True)
        return float(result.stdout)
    
    
    def read_subtitles(filename):
        subtitles = []
        with open(filename, 'r', encoding='utf-8') as file:
            for line in file:
                match = re.match(r'\[(\d+:\d+:\d+)\] (.+)', line.strip())
                if match:
                    time_str, word = match.groups()
                    subtitles.append((parse_time(time_str), word.upper() if UPPER_CASE else word))
        
        audio_duration = get_audio_duration('audio.wav')
        final_timestamp = timedelta(seconds=audio_duration)
        subtitles.append((final_timestamp, ""))
    
        # Processar legendas em frases completas
        sentences = []
        sentence_words = []
        sentence_start_time = None
        sentence_start_index = None
    
        for i, (time, word) in enumerate(subtitles):
            if word == "":
                continue  # Ignora palavras vazias
            if word[0].isupper() and (i == 0 or subtitles[i - 1][1].endswith('.')):
                # Início de uma nova frase
                if sentence_words:
                    # Adiciona a frase anterior à lista
                    sentences.append({
                        'start_time': sentence_start_time,
                        'end_time': subtitles[i - 1][0],  # Tempo final é o tempo da última palavra
                        'words': sentence_words,
                        'start_index': sentence_start_index,
                        'end_index': i,  # Exclusivo
                    })
                # Inicia nova frase
                sentence_words = [word]
                sentence_start_time = time
                sentence_start_index = i
            else:
                sentence_words.append(word)
        # Adiciona a última frase
        if sentence_words:
            sentences.append({
                'start_time': sentence_start_time,
                'end_time': subtitles[-1][0],
                'words': sentence_words,
                'start_index': sentence_start_index,
                'end_index': len(subtitles),
            })
    
        # Inicializar fonte para calcular tamanhos
        font = ImageFont.truetype(FONT_PATH, FONT_SIZE_COMPLETE)
        space_width = font.getlength(' ')
        line_spacing = 10
        max_width = IMAGE_SIZE[0] - 40
    
        for sentence in sentences:
            lines = arrange_sentence_into_lines(sentence['words'], font, max_width, space_width)
            sentence_height = len(lines) * (FONT_SIZE_COMPLETE + line_spacing)
            sentence['lines'] = lines
            sentence['height'] = sentence_height
    
        return subtitles, sentences
    
    
    @lru_cache(maxsize=1000)
    def create_gradient_word(word, width, height, start_color, end_color, progress, font_size):
        font = ImageFont.truetype(FONT_PATH, font_size)
        ascent, descent = font.getmetrics()
        total_height = ascent + descent
    
        padding = 20
        word_image = Image.new('RGBA', (int(width) + padding, total_height + padding), (0, 0, 0, 0))
        draw = ImageDraw.Draw(word_image)
        
        x, y = padding // 2, ascent
    
        # Desenhar o texto principal sem sombra
        draw.text((x, y), word, font=font, fill=hex_to_rgb(end_color), anchor="ls")
        
        mask = Image.new('L', word_image.size, 0)
        mask_draw = ImageDraw.Draw(mask)
        mask_draw.text((x, y), word, font=font, fill=255, anchor="ls")
        mask = mask.filter(ImageFilter.GaussianBlur(radius=1.0))
        
        gradient = Image.new('RGBA', word_image.size, (0, 0, 0, 0))
        start_color_rgb = hex_to_rgb(start_color)
        end_color_rgb = hex_to_rgb(end_color)
        
        for x_coord in range(word_image.width):
            ratio = max(0, min(1, (x_coord / (width + padding) - progress) / 0.1))
            r = int(start_color_rgb[0] + (end_color_rgb[0] - start_color_rgb[0]) * ratio)
            g = int(start_color_rgb[1] + (end_color_rgb[1] - start_color_rgb[1]) * ratio)
            b = int(start_color_rgb[2] + (end_color_rgb[2] - start_color_rgb[2]) * ratio)
            color = (r, g, b, 255)
            ImageDraw.Draw(gradient).line([(x_coord, 0), (x_coord, word_image.height)], fill=color)
        
        gradient.putalpha(mask)
        
        return Image.alpha_composite(word_image, gradient)
    
    
    def arrange_sentence_into_lines(sentence_words, font, max_width, space_width):
        lines = []
        current_line = []
        current_line_width = 0
        for word in sentence_words:
            word_width = font.getlength(word)
            if current_line_width + word_width + (space_width if current_line else 0) > max_width:
                lines.append(current_line)
                current_line = [word]
                current_line_width = word_width + space_width
            else:
                if current_line:
                    current_line_width += word_width + space_width
                else:
                    current_line_width = word_width
                current_line.append(word)
        if current_line:
            lines.append(current_line)
        return lines
    
    
    def process_frame(frame_index, subtitles, sentences, background_image, num_frames):
        current_time = timedelta(seconds=frame_index / FPS)
        image = background_image.copy()
    
        # Inicializar fonte
        font = ImageFont.truetype(FONT_PATH, FONT_SIZE_COMPLETE)
        space_width = font.getlength(' ')
        line_spacing = 10
        max_width = IMAGE_SIZE[0] - 40
    
        sentences_on_screen = []
    
        # Iterar sobre as frases para encontrar as que devem estar na tela
        for sentence in sentences:
            sentence_start_time = sentence['start_time'] - timedelta(seconds=2)  # Começa 2 segundos antes
            sentence_end_time = sentence_start_time + timedelta(seconds=SCROLL_DURATION)
            if sentence_start_time <= current_time <= sentence_end_time:
                time_since_start = (current_time - sentence_start_time).total_seconds()
                progress = time_since_start / SCROLL_DURATION
                sentences_on_screen.append({
                    'sentence': sentence,
                    'progress': progress,
                    'time_since_start': time_since_start
                })
    
        # Limitar a exibição a no máximo 4 frases
        if len(sentences_on_screen) > 4:
            sentences_on_screen = sentences_on_screen[-4:]  # Mantém as últimas 4 frases
    
        # Ordenar as frases pela hora de início
        sentences_on_screen.sort(key=lambda x: x['sentence']['start_time'])
    
        # Calcular altura total das frases na tela
        total_sentences_height = sum([s['sentence']['height'] for s in sentences_on_screen]) + (len(sentences_on_screen) - 1) * SPACING_BETWEEN_SENTENCES
        scroll_distance = IMAGE_SIZE[1] + total_sentences_height  # Distância total a ser percorrida pelas frases
    
        # Desenhar as frases na tela
        cumulative_height = 0
        for idx, item in enumerate(sentences_on_screen):
            sentence = item['sentence']
            progress = item['progress']
            lines = sentence['lines']
            word_index = sentence['start_index']
    
            # Posição inicial y da frase
            initial_y = IMAGE_SIZE[1] + cumulative_height
    
            # Calcular o deslocamento em y baseado no progresso
            y_offset = progress * scroll_distance
            y = initial_y - y_offset
    
            current_y = y
    
            for line in lines:
                line_width = sum(font.getlength(word) for word in line) + space_width * (len(line) -1)
                x = (IMAGE_SIZE[0] - line_width) // 2
    
                for word in line:
                    word_time = subtitles[word_index][0]
                    next_word_time = subtitles[word_index + 1][0] if word_index + 1 < len(subtitles) else word_time + timedelta(seconds=2)
    
                    ascent_word, descent_word = font.getmetrics()
                    text_width = font.getlength(word)
                    y_centered = current_y + ascent_word
    
                    # Decidir cor e progresso para destaque
                    if current_time >= next_word_time:
                        color = FONT_COLOR
                        progress_word = 1.0
                    elif current_time >= word_time:
                        word_duration = (next_word_time - word_time).total_seconds()
                        progress_word = min(max((current_time - word_time).total_seconds() / word_duration, 0.0), 1.0)
                        color = FONT_COLOR
                    else:
                        color = HIGHLIGHT_COLOR
                        progress_word = 1.0
    
                    gradient_image = create_gradient_word(word, text_width, FONT_SIZE_COMPLETE, color, HIGHLIGHT_COLOR, progress_word, FONT_SIZE_COMPLETE)
                    image.paste(gradient_image, (int(x -5), int(y_centered - ascent_word -5)), gradient_image)
    
                    x += text_width + space_width
                    word_index +=1
    
                current_y += FONT_SIZE_COMPLETE + line_spacing
    
            cumulative_height += sentence['height'] + SPACING_BETWEEN_SENTENCES
    
        # Aplicar fade in e fade out
        if frame_index < FADE_DURATION * FPS:
            fade_opacity = frame_index / (FADE_DURATION * FPS)
            fade_overlay = Image.new('RGBA', image.size, (0, 0, 0, int(255 * (1 - fade_opacity))))
            image = Image.alpha_composite(image.convert('RGBA'), fade_overlay).convert('RGB')
        elif frame_index > num_frames - FADE_DURATION * FPS:
            fade_opacity = (num_frames - frame_index) / (FADE_DURATION * FPS)
            fade_overlay = Image.new('RGBA', image.size, (0, 0, 0, int(255 * (1 - fade_opacity))))
            image = Image.alpha_composite(image.convert('RGBA'), fade_overlay).convert('RGB')
    
        # Converter para RGB para salvar como JPEG
        return image.convert('RGB')
    
    
    def generate_frames_chunk(args):
        start_frame, end_frame, subtitles, sentences, output_dir, background_image, num_frames, progress_queue = args
    
        for frame_index in range(start_frame, end_frame):
            try:
                image = process_frame(frame_index, subtitles, sentences, background_image, num_frames)
                frame_filename = os.path.join(output_dir, f"frame_{frame_index:04d}.jpg")
                image.save(frame_filename, quality=95)
                progress_queue.put(1)
            except Exception as e:
                print(f"Erro ao processar o frame {frame_index}: {str(e)}")
                progress_queue.put(1)  # Ainda incrementamos o progresso para evitar travamentos
    
        return end_frame - start_frame
    
    
    def generate_frames_parallel(subtitles, sentences, output_dir, background_image):
        total_duration = (subtitles[-1][0] + timedelta(seconds=2)).total_seconds()
        num_frames = int(total_duration * FPS) + 1
    
        num_processes = multiprocessing.cpu_count()
        chunk_size = num_frames // num_processes + 1
    
        manager = multiprocessing.Manager()
        progress_queue = manager.Queue()
    
        args_list = [
            (i * chunk_size, min((i + 1) * chunk_size, num_frames), subtitles, sentences, output_dir, background_image, num_frames, progress_queue)
            for i in range(num_processes)
        ]
    
        with multiprocessing.Pool(processes=num_processes) as pool:
            with tqdm(total=num_frames, unit='frame', desc='Gerando frames') as pbar:
                results = pool.map_async(generate_frames_chunk, args_list)
                
                while not results.ready():
                    frames_processed = progress_queue.qsize()
                    if frames_processed > 0:
                        pbar.update(frames_processed)
                        for _ in range(frames_processed):
                            progress_queue.get()
                    time.sleep(0.1)
    
                frames_processed = progress_queue.qsize()
                if frames_processed > 0:
                    pbar.update(frames_processed)
    
        # Verificar se todos os frames foram gerados
        expected_frames = num_frames
        generated_frames = len([f for f in os.listdir(output_dir) if f.endswith('.jpg')])
        if generated_frames < expected_frames:
            print(f"Aviso: Apenas {generated_frames} de {expected_frames} frames foram gerados.")
        else:
            print(f"Todos os {expected_frames} frames foram gerados com sucesso.")
    
    
    def create_video(frame_folder, output_video, audio_file):
        frame_pattern = os.path.join(frame_folder, 'frame_%04d.jpg')
        duration = get_audio_duration(audio_file)
        fade_out_start = duration - FADE_DURATION
    
        command = [
            'ffmpeg',
            '-y',
            '-framerate', str(FPS),
            '-i', frame_pattern,
            '-i', audio_file,
            '-c:v', 'h264_nvenc',
            '-preset', 'medium',
            '-rc', 'vbr_hq',
            '-cq', '23',
            '-b:v', '10M',
            '-maxrate', '20M',
            '-bufsize', '20M',
            '-profile:v', 'high',
            '-c:a', 'aac',
            '-profile:a', 'aac_low',
            '-b:a', '448k',
            '-vf', f"fade=t=in:st=0:d={FADE_DURATION},fade=t=out:st={fade_out_start}:d={FADE_DURATION}",
            '-shortest',
            output_video
        ]
        subprocess.run(command, check=True)
    
    
    def main():
        try:
            subtitles, sentences = read_subtitles('legenda.srt')
            output_dir = 'frames'
            os.makedirs(output_dir, exist_ok=True)
    
            background_image_path = r"C:\Users\lucas\OneDrive\Documentos\capa.jpg"
            background_image = Image.open(background_image_path).convert("RGBA").resize(IMAGE_SIZE)
    
            generate_frames_parallel(subtitles, sentences, output_dir, background_image)
            create_video(output_dir, 'output_video.mp4', 'audio.wav')
            shutil.rmtree(output_dir)
        except Exception as e:
            print(f"Erro durante a execução do programa: {str(e)}")
    
    
    if __name__ == "__main__":
        main()
    

    Alterações realizadas:

    1. Definição de um espaçamento entre frases: Adicionei a constante SPACING_BETWEEN_SENTENCES para determinar o espaçamento vertical entre as frases.

    2. Limitação de frases na tela: Na função process_frame, após coletar as frases que devem ser exibidas (sentences_on_screen), limitei o número máximo de frases para 4.

      if len(sentences_on_screen) > 4:
          sentences_on_screen = sentences_on_screen[-4:]  # Mantém as últimas 4 frases
      
    3. Cálculo da posição vertical das frases: Alterei o cálculo da posição y das frases para considerar o deslocamento proporcional ao progresso da animação e o espaçamento entre as frases. O deslocamento vertical agora é calculado com base no progresso (progress) e na scroll_distance, que é a distância total que as frases devem percorrer na tela.

      # Calcular altura total das frases na tela
      total_sentences_height = sum([s['sentence']['height'] for s in sentences_on_screen]) + (len(sentences_on_screen) - 1) * SPACING_BETWEEN_SENTENCES
      scroll_distance = IMAGE_SIZE[1] + total_sentences_height  # Distância total a ser percorrida pelas frases
      
      # Desenhar as frases na tela
      cumulative_height = 0
      for idx, item in enumerate(sentences_on_screen):
          sentence = item['sentence']
          progress = item['progress']
          # Posição inicial y da frase
          initial_y = IMAGE_SIZE[1] + cumulative_height
      
          # Calcular o deslocamento em y baseado no progresso
          y_offset = progress * scroll_distance
          y = initial_y - y_offset
      
          current_y = y
          # ... (Desenho das linhas da frase)
          cumulative_height += sentence['height'] + SPACING_BETWEEN_SENTENCES
      

    Com essas alterações, as frases serão exibidas de forma sincronizada, com até 4 frases na tela ao mesmo tempo, rolando para cima de maneira organizada e precisa.

    Espero que isso atenda à sua solicitação.