A palavra destacada, ou seja, a que o vermelho está passando, fica um pouco para cima, preciso que ela fique na mesma posição das demais palavras

Mande o código completo.

```python
import re
from datetime import timedelta
from PIL import Image, ImageDraw, ImageFont, ImageFilter
import subprocess
import os
import multiprocessing

font_size = 35
image_size = (1280, 720)
font_color = (255, 0, 0)  # Vermelho
highlight_color = (255, 255, 255)  # Branco
upper_case = True
fps = 20

def parse_time(time_str):
    match = re.match(r'(\d+):(\d+):(\d+)', time_str)
    if match:
        minutes, seconds, milliseconds = map(int, match.groups())
        time = timedelta(minutes=minutes, seconds=seconds, milliseconds=milliseconds)
        return time
    return timedelta(0)

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))
    return subtitles

def create_gradient_word(word, font, width, height, start_color, end_color, progress):
    word_image = Image.new('RGBA', (int(width), height), (0, 0, 0, 0))
    draw = ImageDraw.Draw(word_image)
    
    ascent, descent = font.getmetrics()
    text_width, text_height = font.getsize(word)
    
    x = 0
    y = height - descent
    
    draw.text((x, y), word, font=font, fill=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=0.5))
    
    gradient = Image.new('RGBA', word_image.size, (0, 0, 0, 0))
    for x in range(word_image.width):
        ratio = max(0, min(1, (x / width - progress) / 0.1))
        r = int(start_color[0] + (end_color[0] - start_color[0]) * ratio)
        g = int(start_color[1] + (end_color[1] - start_color[1]) * ratio)
        b = int(start_color[2] + (end_color[2] - start_color[2]) * ratio)
        color = (r, g, b, 255)
        ImageDraw.Draw(gradient).line([(x, 0), (x, word_image.height)], fill=color)
    
    gradient.putalpha(mask)
    
    return gradient

def generate_frames_chunk(args):
    start_frame, end_frame, subtitles, output_dir, font_path, image_size, highlight_color, font_color, fps, upper_case = args

    font = ImageFont.truetype(font_path, font_size)
    space_width = font.getlength(' ')

    max_words_per_line = 7
    num_lines = 3
    line_spacing = 10

    if upper_case:
        words = [word.upper() for t, word in subtitles]
    else:
        words = [word for t, word in subtitles]
    word_widths = [font.getlength(word) for word in words]

    background_image = Image.open("background.jpg").convert("RGB")
    background_image = background_image.resize(image_size)

    total_duration = (subtitles[-1][0] + timedelta(seconds=2)).total_seconds()

    for frame_index in range(start_frame, end_frame):
        current_time = timedelta(seconds=frame_index / fps)
        image = background_image.copy()
        draw = ImageDraw.Draw(image)

        total_height = num_lines * font_size + (num_lines - 1) * line_spacing
        y = (image_size[1] - total_height) // 2

        current_word_index = 0
        for i, (word_time, _) in enumerate(subtitles):
            if word_time > current_time:
                current_word_index = max(0, i - 1)
                break
        else:
            current_word_index = len(subtitles) - 1

        start_index = (current_word_index // (max_words_per_line * num_lines)) * (max_words_per_line * num_lines)

        for line in range(num_lines):
            line_start = start_index + line * max_words_per_line
            line_end = min(line_start + max_words_per_line, len(words))
            line_words = words[line_start:line_end]
            line_widths = word_widths[line_start:line_end]
            
            total_width = sum(line_widths) + space_width * (len(line_words) - 1)
            start_x = (image_size[0] - total_width) // 2
            x = start_x

            for i, word in enumerate(line_words):
                word_index = line_start + i
                word_time = subtitles[word_index][0]
                
                if word_index + 1 < len(subtitles):
                    next_word_time = subtitles[word_index + 1][0]
                else:
                    next_word_time = word_time + timedelta(seconds=2)

                ascent, descent = font.getmetrics()
                text_width, text_height = font.getsize(word)
                y_centered = y + ascent

                if current_time >= next_word_time:
                    draw.text((x, y_centered), word, font=font, fill=font_color, anchor="ls")
                elif current_time >= word_time:
                    word_duration = (next_word_time - word_time).total_seconds()
                    progress = (current_time - word_time).total_seconds() / word_duration
                    progress = min(max(progress, 0.0), 1.0)
                    gradient_image = create_gradient_word(word, font, line_widths[i], font_size, font_color, highlight_color, progress)
                    image.paste(gradient_image, (int(x), int(y)), gradient_image)
                else:
                    draw.text((x, y_centered), word, font=font, fill=highlight_color, anchor="ls")

                x += line_widths[i] + space_width

            y += font_size + line_spacing

        frame_filename = os.path.join(output_dir, f"frame_{frame_index:04d}.jpg")
        image.save(frame_filename)

def generate_frames_parallel(subtitles, output_dir):
    font_path = os.path.join(os.path.dirname(__file__), "impact.ttf")
    font = ImageFont.truetype(font_path, font_size)
    space_width = font.getlength(' ')

    # Calculate total duration
    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

    args_list = [
        (
            i * chunk_size,
            min((i + 1) * chunk_size, num_frames),
            subtitles,
            output_dir,
            font_path,
            image_size,
            highlight_color,
            font_color,
            fps,
            upper_case
        )
        for i in range(num_processes)
    ]

    with multiprocessing.Pool() as pool:
        pool.map(generate_frames_chunk, args_list)

def create_video(frame_folder, output_video, framerate, audio_file):
    frame_pattern = os.path.join(frame_folder, 'frame_%04d.jpg')
    command = [
        'ffmpeg',
        '-y',
        '-framerate', str(framerate),
        '-i', frame_pattern,
        '-i', audio_file,
        '-c:v', 'h264_nvenc',
        '-preset', 'slow',
        '-crf', '23',
        '-c:a', 'aac',
        '-strict', 'experimental',
        '-shortest',
        output_video
    ]
    subprocess.run(command, check=True)

if __name__ == "__main__":
    subtitles = read_subtitles('legenda.srt')
    output_dir = 'frames'
    os.makedirs(output_dir, exist_ok=True)

    generate_frames_parallel(subtitles, output_dir)
    create_video(output_dir, 'output_video.mp4', fps, 'audio.wav')
```