tool_video_analyzer.py

# -*- coding: utf-8 -*-
"""
Script para baixar um vídeo do YouTube, extrair frames, analisar com GPT-4o e contar aves.
"""

import os
import subprocess
import cv2
import base64
import time
from openai import OpenAI # Importa a classe OpenAI
import json
import re 
import shutil

import google.generativeai as genai


# --- Configurações (Substitua os placeholders) ---
VIDEO_URL = "https://www.youtube.com/watch?v=L1vXCYZAYYM"  # Substitua pela URL do vídeo do YouTube
OUTPUT_DIR = "./video_analysis_output" # Diretório para salvar o vídeo e os frames
FRAME_INTERVAL_SECONDS = 0.5 # Intervalo entre frames a serem extraídos
INICIO_FRAME_IMPORTANTE  = 191 # inicio intervalo relevante, para não ficar caro a inferencia ao gpt
FIM_FRAME_IMPORTANTE = 193# fim intervalo relevante, para não ficar caro a inferencia ao gpt
OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
GPT_MODEL = "gpt-4o" # Modelo GPT a ser usado (certifique-se que é o correto para análise de imagem)
GEMINI_MODEL = "gemini-2.0-flash"
#PROMPT_TEXT = "You are an image analyzer, do not return any explanation. If asked to count items, return only an integer. If in doubt, return 0. How many different bird species are visible in the image?" # Prompt para o GPT-4o
#PROMPT_TEXT = "You are an expert in visual species classification. Based on the image provided, determine and return the number of distinct bird species visible. Do not count individuals — only count different species based on visual traits like size, shape, color, and beak structure. Return only a single integer. If unsure, return your best estimate. Do not provide explanations or any extra text."
#PROMPT_TEXT = "You are an expert in visual species classification. Based on the image provided, determine and return the number of distinct bird species visible. Do not count individuals — only count different species based on visual traits like size, shape, color, and beak structure. Return only a single integer. If unsure, return your best estimate. Do not provide explanations or any extra text."
PROMPT_TEXT = "You are a world-class expert in avian species classification. Analyze the provided image and determine how many **distinct bird species** are present. Consider size, shape, plumage, coloration, and beak structure. Focus only on visible morphological differences. Return a **single integer** with no explanation. Do not count individuals of the same species. If unsure, assume that bird is a different specie."

RESULTS_FILE = os.path.join(OUTPUT_DIR, "analysis_results.json")
VIDEO_FILENAME = "downloaded_video.mp4"
VIDEO_PATH = os.path.join(OUTPUT_DIR, VIDEO_FILENAME)

# Verifica se a chave da API foi definida
if OPENAI_API_KEY == "SUA_CHAVE_API_OPENAI_AQUI":
    print("AVISO: A chave da API OpenAI não foi definida. Por favor, edite o script e insira sua chave.")
    # Considerar sair do script ou lançar um erro se a chave for essencial para a execução completa
    # exit(1)

if GEMINI_API_KEY == "SUA_CHAVE_API_OPENAI_AQUI" or not GEMINI_API_KEY or len(GEMINI_API_KEY) ==0 :
    print("AVISO: A chave da API GEMINI não foi definida. Por favor, edite o script e insira sua chave.")
    # Considerar sair do script ou lançar um erro se a chave for essencial para a execução completa
    # exit(1)

# Verifica se a URL foi definida
if VIDEO_URL == "URL_DO_SEU_VIDEO_AQUI":
    print("AVISO: A URL do vídeo não foi definida. Por favor, edite o script e insira a URL desejada.")
    # exit(1)

# --- Funções ---

def create_or_clear_output_directory():
    """Cria o diretório de saída se não existir."""
    if not os.path.exists(OUTPUT_DIR):
        os.makedirs(OUTPUT_DIR)
        print(f"Diretório criado: {OUTPUT_DIR}")
    else:    
        # Limpa todos os arquivos e subdiretórios
        for filename in os.listdir(OUTPUT_DIR):
            file_path = os.path.join(OUTPUT_DIR, filename)
            try:
                if os.path.isfile(file_path) or os.path.islink(file_path):
                    os.unlink(file_path)
                elif os.path.isdir(file_path):
                    shutil.rmtree(file_path)
            except Exception as e:
                print(f"Erro ao excluir {file_path}: {e}")
        print(f"Diretório limpo: {OUTPUT_DIR}")
        
def retirar_sufixo_codec_arquivo(directory) -> None:
    for filename in os.listdir(directory):
        # Procura padrão como ".f123" antes da extensão
        new_filename = re.sub(r'\.f\d{3}(?=\.\w+$)', '', filename)
        if new_filename != filename:
            old_path = os.path.join(directory, filename)
            new_path = os.path.join(directory, new_filename)
            os.rename(old_path, new_path)
            print(f"Renomeado: {filename} → {new_filename}")
            

def download_video(url, output_path):
    """Baixa o vídeo do YouTube usando yt-dlp."""
    print(f"Baixando vídeo de {url} para {output_path}...")
    try:
        # Comando yt-dlp para baixar o melhor formato mp4
        command = [
            'yt-dlp',
            '-f', 'bestvideo[ext=mp4]+bestaudio[ext=m4a]/best[ext=mp4]/best',
            '-o', output_path,
            url
        ]
        result = subprocess.run(command, check=True, capture_output=True, text=True)
        print("Download concluído com sucesso.")
        retirar_sufixo_codec_arquivo(OUTPUT_DIR)
        # print(result.stdout) # Descomente para ver a saída do yt-dlp
        return True
    except subprocess.CalledProcessError as e:
        print(f"Erro ao baixar o vídeo: {e}")
        print(f"Saída do erro: {e.stderr}")
        return False
    except FileNotFoundError:
        print("Erro: O comando 'yt-dlp' não foi encontrado. Certifique-se de que ele está instalado e no PATH do sistema.")
        print("Você pode instalá-lo com: pip install yt-dlp")
        return False


def extract_frames(video_path, output_dir, interval_sec):
    """Extrai frames de um vídeo em intervalos específicos."""
    print(f"Extraindo frames de {video_path} a cada {interval_sec} segundos...")
    if not os.path.exists(video_path):
        print(f"Erro: Arquivo de vídeo não encontrado em {video_path}")
        return []

    cap = cv2.VideoCapture(video_path)
    # Verificar a resolução
    width = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH))
    height = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT))
    print(f"Resolução original do vídeo: {width}x{height}")    
    
    if not cap.isOpened():
        print(f"Erro ao abrir o arquivo de vídeo: {video_path}")
        return []

    fps = cap.get(cv2.CAP_PROP_FPS)
    if fps == 0:
        print("Erro: Não foi possível obter o FPS do vídeo. Usando FPS padrão de 30.")
        fps = 30 # Valor padrão caso a leitura falhe

    # retirado para permitir fracionado frame_interval = int(fps * interval_sec)
    frame_interval = fps * interval_sec
    
    total_frames = int(cap.get(cv2.CAP_PROP_FRAME_COUNT))
    print(f"Vídeo FPS: {fps:.2f}, Intervalo de frames: {frame_interval}, Total de frames: {total_frames}")

    extracted_frames_paths = []
    frame_count = 0
    saved_frame_index = 5 # o importante nunca começa no inicio, é um deslocamento inicial para iniciar depois da introdução


    while True:
        # Define a posição do próximo frame a ser lido
        # Adiciona frame_interval para pegar o frame *após* o intervalo de tempo
        # ajustado para float target_frame_pos = saved_frame_index * frame_interval
        target_frame_pos = int(saved_frame_index * frame_interval)

        if target_frame_pos >= total_frames:
            break # Sai se o próximo frame alvo estiver além do final do vídeo

        if (saved_frame_index < INICIO_FRAME_IMPORTANTE or saved_frame_index > FIM_FRAME_IMPORTANTE):
            print(f"Pulando frame {saved_frame_index}")
            saved_frame_index += 1
            continue # evitar custo desnecessário para inferencia ao gpt
        cap.set(cv2.CAP_PROP_POS_FRAMES, target_frame_pos)
        ret, frame = cap.read()

        if not ret:
            print(f"Não foi possível ler o frame na posição {target_frame_pos}. Pode ser o fim do vídeo ou um erro.")
            break # Sai se não conseguir ler o frame

        # redimensiona o frame (custo chamada)
        # removido porque poderia afetar a nitidez e impactar o resultado
        # frame = cv2.resize(frame, (1280, 720))
        
        # Calcula o timestamp em segundos
        timestamp_sec = target_frame_pos / fps

        # Salva o frame
        frame_filename = f"frame_{saved_frame_index:04d}_time_{timestamp_sec:.2f}s.png"
        frame_path = os.path.join(output_dir, frame_filename)
        try:
            # modificado para salvar com qualidade máxima cv2.imwrite(frame_path, frame)
            cv2.imwrite(frame_path, frame, [cv2.IMWRITE_PNG_COMPRESSION, 0])

            extracted_frames_paths.append(frame_path)
            print(f"Frame salvo: {frame_path} (Timestamp: {timestamp_sec:.2f}s)")
            saved_frame_index += 1
        except Exception as e:
            print(f"Erro ao salvar o frame {frame_path}: {e}")
            # Continua para o próximo intervalo mesmo se um frame falhar

        # Segurança para evitar loop infinito caso algo dê errado com a lógica de posição
        if saved_frame_index > (total_frames / frame_interval) + 2:
             print("Aviso: Número de frames salvos parece exceder o esperado. Interrompendo extração.")
             break

    cap.release()
    print(f"Extração de frames concluída. Total de frames salvos: {len(extracted_frames_paths)}")
    return extracted_frames_paths

# --- Atualização do Bloco Principal ---
# (Remover a linha print anterior sobre próximas etapas e adicionar a chamada da nova função)




def encode_frame_to_base64(frame_path):
    """Codifica um arquivo de imagem (frame) para base64."""
    try:
        with open(frame_path, "rb") as image_file:
            return base64.b64encode(image_file.read()).decode('utf-8')
    except FileNotFoundError:
        print(f"Erro: Arquivo de frame não encontrado em {frame_path}")
        return None
    except Exception as e:
        print(f"Erro ao codificar o frame {frame_path} para base64: {e}")
        return None



def analyze_frame_with_gpt4o(client, base64_image, prompt):

    """Envia um frame codificado em base64 para a API GPT-4o e retorna a análise."""
    print(f"Enviando frame para análise no {GPT_MODEL}...")
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    payload = {
        "model": GPT_MODEL,
        "messages": [
            {
                "role": "user",
                "content": [
                    {
                        "type": "text",
                        "text": prompt
                    },
                    {
                        "type": "image_url",
                        "image_url": {
                            "url": f"data:image/png;base64,{base64_image}"
                        }
                    }
                ]
            }
        ],
        "max_tokens": 100 # Ajuste conforme necessário para a resposta esperada
    }

    try:
        # Verifica se a chave da API é o placeholder
        if OPENAI_API_KEY == "SUA_CHAVE_API_OPENAI_AQUI":
             print("AVISO: Chave da API OpenAI não configurada. Pulando análise.")
             return {"error": "API key not configured."}

        # Cria o cliente OpenAI dentro da função para garantir que use a chave mais recente
        # (embora seja definida globalmente, isso pode ser útil se a chave for atualizada dinamicamente no futuro)
        # client = OpenAI(api_key=OPENAI_API_KEY)

        response = client.chat.completions.create(
            model=payload["model"],
            messages=payload["messages"],
            max_tokens=payload["max_tokens"]
        )

        # Extrai o conteúdo da resposta
        analysis_result = response.choices[0].message.content.strip()
        print(f"Análise recebida: {analysis_result}")
        # Tenta converter a resposta para um inteiro (contagem de aves)
        try:
            bird_count = int(analysis_result)
            return {"bird_count": bird_count, "raw_response": analysis_result}
        except ValueError:
            print(f"Aviso: Não foi possível converter a resposta '{analysis_result}' para um número inteiro.")
            return {"error": "Failed to parse bird count from response.", "raw_response": analysis_result}

    except Exception as e:
        print(f"Erro ao chamar a API OpenAI: {e}")
        return {"error": str(e)}
 

def analyze_frame_with_gemini(base64_image, prompt):
    genai.configure(api_key=GEMINI_API_KEY)
    model = genai.GenerativeModel(GEMINI_MODEL)

    """Envia um frame codificado em base64 para a API GPT-4o e retorna a análise."""
    print(f"Enviando frame para análise no {GEMINI_MODEL}...")
    headers = {
        "Content-Type": "application/json",
        "Authorization": f"Bearer {OPENAI_API_KEY}"
    }

    try:

        response = model.generate_content(
            contents=[
                {
                    "role": "user",
                    "parts": [
                        {f"text": f"{prompt}"},
                        {"inline_data": {
                            "mime_type": "image/jpeg",
                            "data": base64_image
                        }}
                    ]
                }
            ],
            generation_config={
                "temperature": 0.7,
                "max_output_tokens": 500
            })

        # Extrai o conteúdo da resposta
        analysis_result = response.text.strip()
        print(f"Análise recebida: {analysis_result}")
        # Tenta converter a resposta para um inteiro (contagem de aves)
        try:
            bird_count = int(analysis_result)
            return {"bird_count": bird_count, "raw_response": analysis_result}
        except ValueError:
            print(f"Aviso: Não foi possível converter a resposta '{analysis_result}' para um número inteiro.")
            return {"error": "Failed to parse bird count from response.", "raw_response": analysis_result}

    except Exception as e:
        print(f"Erro ao chamar a API OpenAI: {e}")
        return {"error": str(e)}


 

def save_results_to_json(results_list, output_file):
    """Salva a lista de resultados da análise em um arquivo JSON."""
    print(f"Salvando resultados da análise em {output_file}...")
    try:
        with open(output_file, 'w', encoding='utf-8') as f:
            json.dump(results_list, f, ensure_ascii=False, indent=4)
        print(f"Resultados salvos com sucesso em: {output_file}")
        return True
    except Exception as e:
        print(f"Erro ao salvar os resultados em JSON: {e}")
        return False
    

# --- Atualização do Bloco Principal --- 
# (Adicionar inicialização do cliente OpenAI e o loop de análise)
if __name__ == "__main__":
    create_or_clear_output_directory()
    extracted_frames = []
    analysis_results_list = []

    # Inicializa o cliente OpenAI (se a chave estiver definida)
    openai_client = None
    if OPENAI_API_KEY != "SUA_CHAVE_API_OPENAI_AQUI":
        try:
            openai_client = OpenAI(api_key=OPENAI_API_KEY)
            print("Cliente OpenAI inicializado.")
        except Exception as e:
            print(f"Erro ao inicializar o cliente OpenAI: {e}. As chamadas de API serão puladas.")
    else:
        print("Chave da API OpenAI não configurada. As chamadas de API serão puladas.")

    # Etapa 1: Baixar o vídeo
    video_downloaded_or_exists = False
    if VIDEO_URL != "URL_DO_SEU_VIDEO_AQUI":
        if download_video(VIDEO_URL, VIDEO_PATH):
            print(f"Vídeo salvo em: {VIDEO_PATH}")
            video_downloaded_or_exists = True
        else:
            print("Falha no download do vídeo. Pulando etapas dependentes.")
    elif os.path.exists(VIDEO_PATH):
         print(f"URL não fornecida, mas vídeo encontrado em {VIDEO_PATH}. Tentando processar.")
         video_downloaded_or_exists = True
    else:
        print("URL do vídeo não fornecida e vídeo local não encontrado. Pulando download e extração.")

    # Etapa 2: Extrair frames
    if video_downloaded_or_exists:
        extracted_frames = extract_frames(VIDEO_PATH, OUTPUT_DIR, FRAME_INTERVAL_SECONDS)
    else:
        print("Pulando extração de frames pois o vídeo não está disponível.")
    
    # Etapa 3 e 4: Codificar e Analisar Frames
    if extracted_frames and openai_client:
        print(f"\nIniciando análise de {len(extracted_frames)} frames com {GPT_MODEL}...")
        for frame_path in extracted_frames:
            print(f"\nProcessando frame: {frame_path}")
            # Extrai timestamp do nome do arquivo, se possível
            timestamp_str = "unknown"
            try:
                # Exemplo: frame_0000_time_0.00s.png
                parts = os.path.basename(frame_path).split('_')
                if len(parts) >= 4 and parts[2] == 'time':
                   timestamp_str = parts[3].replace('s.png','')
            except Exception:
                pass # Mantém 'unknown' se o parsing falhar

            # Codifica o frame
            base64_image = encode_frame_to_base64(frame_path)
            
            if  base64_image:
                # Analisa o frame com GPT-4o ou Gemini
                analysis_result = analyze_frame_with_gemini(base64_image, PROMPT_TEXT) #analyze_frame_with_gpt4o(openai_client, base64_image, PROMPT_TEXT)
                result_entry = {
                    "frame_path": frame_path,
                    "timestamp_approx_sec": timestamp_str,
                    "analysis": analysis_result
                }
                analysis_results_list.append(result_entry)

                # Pausa opcional para evitar rate limiting
                time.sleep(1) # Pausa de 1 segundo entre as chamadas
            else:
                print(f"Falha ao codificar o frame {frame_path}. Pulando análise.")
                analysis_results_list.append({
                    "frame_path": frame_path,
                    "timestamp_approx_sec": timestamp_str,
                    "analysis": {"error": "Failed to encode frame to base64."}
                })
                
            # break # teste somente uma chamada
        print("\nAnálise de todos os frames concluída.")
    elif not extracted_frames:
        print("Nenhum frame foi extraído. Pulando etapa de análise.")
    elif not openai_client:
        print("Cliente OpenAI não inicializado (verifique a API Key). Pulando etapa de análise.")

    # Próxima etapa: Compilar resultados
    print(f"\nPróxima etapa a ser implementada: Compilação dos resultados ({len(analysis_results_list)} análises) em um relatório.")


    # ... (código anterior para inicialização, download, extração, análise) ...

    # Etapa 5: Compilar e Salvar Resultados
    if analysis_results_list:
        print(f"\nCompilando {len(analysis_results_list)} resultados da análise...")
        if save_results_to_json(analysis_results_list, RESULTS_FILE):
            print("Compilação e salvamento dos resultados concluídos.")
        else:
            print("Falha ao salvar os resultados da análise.")
    else:
        print("Nenhum resultado de análise para compilar.")

    print("\n--- Processo de Análise de Vídeo Concluído ---")
    print(f"Verifique o diretório '{OUTPUT_DIR}' para os frames extraídos (se aplicável).")
    print(f"Verifique o arquivo '{RESULTS_FILE}' para os resultados da análise (se aplicável).")
    print("Lembre-se de substituir os placeholders para URL_DO_SEU_VIDEO_AQUI e SUA_CHAVE_API_OPENAI_AQUI no script.")