Analisar arquivos de vídeo usando a API Gemini

Você pode pedir a um modelo Gemini para analisar arquivos de vídeo que você fornece inline (codificados em base64) ou por URL. Ao usar Firebase AI Logic, é possível fazer essa solicitação diretamente do app.

Com esse recurso, é possível:

  • Legendar e responder a perguntas sobre vídeos
  • Analisar segmentos específicos de um vídeo usando marcações de tempo
  • Transcrever conteúdo de vídeo processando a faixa de áudio e os frames visuais
  • Descrever, segmentar e extrair informações de vídeos, incluindo a faixa de áudio e os frames visuais

Ir para exemplos de código Ir para o código de respostas transmitidas


Confira outros guias para mais opções de trabalho com vídeo
Gerar saída estruturada Chat em várias etapas

Antes de começar

Clique no seu provedor de Gemini API para conferir o conteúdo e o código específicos do provedor nesta página.

Se ainda não tiver feito isso, conclua o guia de primeiros passos, que descreve como configurar seu projeto do Firebase, conectar seu app ao Firebase, adicionar o SDK, inicializar o serviço de back-end para o provedor Gemini API escolhido e criar uma instância GenerativeModel.

Para testar e iterar em seus comandos e até mesmo receber um snippet de código gerado, recomendamos usar Google AI Studio.

Gerar texto com base em arquivos de vídeo (codificados em base64)

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página.

Você pode pedir a um modelo Gemini para gerar texto usando comandos de texto e vídeo, fornecendo o mimeType de cada arquivo de entrada e o arquivo em si. Confira os requisitos e as recomendações para arquivos de entrada mais adiante nesta página.

Este exemplo mostra como fornecer o arquivo inline, mas os SDKs também permitem fornecer um URL do YouTube.

Swift

Você pode chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.


import FirebaseAI

// Initialize the Gemini Developer API backend service
let ai = FirebaseAI.firebaseAI(backend: .googleAI())

// Create a `GenerativeModel` instance with a model that supports your use case
let model = ai.generativeModel(modelName: "gemini-2.5-flash")


// Provide the video as `Data` with the appropriate MIME type.
let video = InlineDataPart(data: try Data(contentsOf: videoURL), mimeType: "video/mp4")

// Provide a text prompt to include with the video
let prompt = "What is in the video?"

// To generate text output, call generateContent with the text and video
let response = try await model.generateContent(video, prompt)
print(response.text ?? "No text in response.")

Kotlin

Você pode chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.

Para Kotlin, os métodos neste SDK são funções de suspensão e precisam ser chamados de um escopo de corrotina.

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
val model = Firebase.ai(backend = GenerativeBackend.googleAI())
                        .generativeModel("gemini-2.5-flash")


val contentResolver = applicationContext.contentResolver
contentResolver.openInputStream(videoUri).use { stream ->
  stream?.let {
    val bytes = stream.readBytes()

    // Provide a prompt that includes the video specified above and text
    val prompt = content {
        inlineData(bytes, "video/mp4")
        text("What is in the video?")
    }

    // To generate text output, call generateContent with the prompt
    val response = generativeModel.generateContent(prompt)
    Log.d(TAG, response.text ?: "")
  }
}

Java

Você pode chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.

Para Java, os métodos neste SDK retornam um ListenableFuture.

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
GenerativeModel ai = FirebaseAI.getInstance(GenerativeBackend.googleAI())
        .generativeModel("gemini-2.5-flash");

// Use the GenerativeModelFutures Java compatibility layer which offers
// support for ListenableFuture and Publisher APIs
GenerativeModelFutures model = GenerativeModelFutures.from(ai);


ContentResolver resolver = getApplicationContext().getContentResolver();
try (InputStream stream = resolver.openInputStream(videoUri)) {
    File videoFile = new File(new URI(videoUri.toString()));
    int videoSize = (int) videoFile.length();
    byte[] videoBytes = new byte[videoSize];
    if (stream != null) {
        stream.read(videoBytes, 0, videoBytes.length);
        stream.close();

        // Provide a prompt that includes the video specified above and text
        Content prompt = new Content.Builder()
                .addInlineData(videoBytes, "video/mp4")
                .addText("What is in the video?")
                .build();

        // To generate text output, call generateContent with the prompt
        ListenableFuture<GenerateContentResponse> response = model.generateContent(prompt);
        Futures.addCallback(response, new FutureCallback<GenerateContentResponse>() {
            @Override
            public void onSuccess(GenerateContentResponse result) {
                String resultText = result.getText();
                System.out.println(resultText);
            }

            @Override
            public void onFailure(Throwable t) {
                t.printStackTrace();
            }
        }, executor);
    }
} catch (IOException e) {
    e.printStackTrace();
} catch (URISyntaxException e) {
    e.printStackTrace();
}

Web

Você pode chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.


import { initializeApp } from "firebase/app";
import { getAI, getGenerativeModel, GoogleAIBackend } from "firebase/ai";

// TODO(developer) Replace the following with your app's Firebase configuration
// See: https://firebase.google.com/docs/web/learn-more#config-object
const firebaseConfig = {
  // ...
};

// Initialize FirebaseApp
const firebaseApp = initializeApp(firebaseConfig);

// Initialize the Gemini Developer API backend service
const ai = getAI(firebaseApp, { backend: new GoogleAIBackend() });

// Create a `GenerativeModel` instance with a model that supports your use case
const model = getGenerativeModel(ai, { model: "gemini-2.5-flash" });


// Converts a File object to a Part object.
async function fileToGenerativePart(file) {
  const base64EncodedDataPromise = new Promise((resolve) => {
    const reader = new FileReader();
    reader.onloadend = () => resolve(reader.result.split(',')[1]);
    reader.readAsDataURL(file);
  });
  return {
    inlineData: { data: await base64EncodedDataPromise, mimeType: file.type },
  };
}

async function run() {
  // Provide a text prompt to include with the video
  const prompt = "What do you see?";

  const fileInputEl = document.querySelector("input[type=file]");
  const videoPart = await fileToGenerativePart(fileInputEl.files[0]);

  // To generate text output, call generateContent with the text and video
  const result = await model.generateContent([prompt, videoPart]);

  const response = result.response;
  const text = response.text();
  console.log(text);
}

run();

Dart

Você pode chamar generateContent() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.


import 'package:firebase_ai/firebase_ai.dart';
import 'package:firebase_core/firebase_core.dart';
import 'firebase_options.dart';

// Initialize FirebaseApp
await Firebase.initializeApp(
  options: DefaultFirebaseOptions.currentPlatform,
);

// Initialize the Gemini Developer API backend service
// Create a `GenerativeModel` instance with a model that supports your use case
final model =
      FirebaseAI.googleAI().generativeModel(model: 'gemini-2.5-flash');


// Provide a text prompt to include with the video
final prompt = TextPart("What's in the video?");

// Prepare video for input
final video = await File('video0.mp4').readAsBytes();

// Provide the video as `Data` with the appropriate mimetype
final videoPart = InlineDataPart('video/mp4', video);

// To generate text output, call generateContent with the text and images
final response = await model.generateContent([
  Content.multi([prompt, ...videoPart])
]);
print(response.text);

Unity

Você pode chamar GenerateContentAsync() para gerar texto com base em entradas multimodais de arquivos de texto e vídeo.


using Firebase;
using Firebase.AI;

// Initialize the Gemini Developer API backend service
var ai = FirebaseAI.GetInstance(FirebaseAI.Backend.GoogleAI());

// Create a `GenerativeModel` instance with a model that supports your use case
var model = ai.GetGenerativeModel(modelName: "gemini-2.5-flash");


// Provide the video as `data` with the appropriate MIME type.
var video = ModelContent.InlineData("video/mp4",
      System.IO.File.ReadAllBytes(System.IO.Path.Combine(
          UnityEngine.Application.streamingAssetsPath, "yourVideo.mp4")));

// Provide a text prompt to include with the video
var prompt = ModelContent.Text("What is in the video?");

// To generate text output, call GenerateContentAsync with the text and video
var response = await model.GenerateContentAsync(new [] { video, prompt });
UnityEngine.Debug.Log(response.Text ?? "No text in response.");

Saiba como escolher um modelo adequado para seu caso de uso e app.

Mostrar composição da resposta

Antes de testar esta amostra, conclua a seção Antes de começar deste guia para configurar seu projeto e app.
Nessa seção, clique também em um botão do provedor de Gemini API escolhido para ver o conteúdo específico do provedor nesta página.

Para ter interações mais rápidas, não espere o resultado completo da geração do modelo. Em vez disso, use o streaming para processar resultados parciais. Para transmitir a resposta, chame generateContentStream.



Requisitos e recomendações para arquivos de vídeo de entrada

Um arquivo fornecido como dados in-line é codificado em base64 em trânsito, o que aumenta o tamanho da solicitação. Você recebe um erro HTTP 413 se uma solicitação for muito grande.

Consulte "Arquivos de entrada e requisitos compatíveis com o Vertex AI Gemini API" para saber mais sobre:

Tipos MIME de vídeo compatíveis

Os modelos multimodais do Gemini são compatíveis com os seguintes tipos MIME de vídeo:

Tipo de vídeo MIME Gemini 2.0 Flash Gemini 2.0 Flash‑Lite
FLV - video/x-flv
MOV - video/quicktime
MPEG - video/mpeg
MPEGPS - video/mpegps
MPG - video/mpg
MP4 - video/mp4
WEBM - video/webm
WMV - video/wmv
3GPP - video/3gpp

Limites por solicitação

Este é o número máximo de arquivos de vídeo permitidos em uma solicitação de comando:

  • Gemini 2.0 Flash e Gemini 2.0 Flash‑Lite: 10 arquivos de vídeo



O que mais você sabe fazer?

Testar outros recursos

Saiba como controlar a geração de conteúdo

Você também pode testar comandos e configurações de modelo e até mesmo receber um snippet de código gerado usando Google AI Studio.

Saiba mais sobre os modelos compatíveis

Saiba mais sobre os modelos disponíveis para vários casos de uso e as respectivas cotas e preços.


Enviar feedback sobre sua experiência com Firebase AI Logic