Object Storage Service:Video-to-animated-image conversion

Visão geral

A conversão de vídeo para imagem animada transforma um arquivo de vídeo em um formato de imagem animada, como GIF ou WebP, facilitando o compartilhamento e a incorporação em sites e redes sociais.

Cenários de uso

• Compartilhamento em redes sociais: As imagens animadas permitem que os usuários compartilhem clipes de vídeo curtos em plataformas sociais para expressar emoções, momentos engraçados ou informações importantes.

• Memes online: Converta vídeos em imagens animadas para criar memes divertidos ou engraçados que enriquecem as conversas online.

• Tutoriais e demonstrações: Utilize imagens animadas em aulas ou demonstrações para mostrar operações de software ou instruções passo a passo, ajudando os espectadores a compreender rapidamente conceitos e procedimentos complexos.

• Transmissões ao vivo e replays de eventos: Durante jogos, eventos ou transmissões ao vivo, use imagens animadas para recortar e compartilhar rapidamente momentos emocionantes com os espectadores, aumentando o engajamento.

Como usar

import com.aliyun.oss.ClientBuilderConfiguration;
import com.aliyun.oss.OSS;
import com.aliyun.oss.OSSClientBuilder;
import com.aliyun.oss.common.auth.CredentialsProviderFactory;
import com.aliyun.oss.common.auth.EnvironmentVariableCredentialsProvider;
import com.aliyun.oss.common.comm.SignVersion;
import com.aliyun.oss.model.AsyncProcessObjectRequest;
import com.aliyun.oss.model.AsyncProcessObjectResult;
import com.aliyuncs.exceptions.ClientException;

import java.util.Base64;

public class Demo {
    public static void main(String[] args) throws ClientException {
        // The endpoint of the region in which the bucket is located.
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // The region that corresponds to the endpoint, for example, cn-hangzhou.
        String region = "cn-hangzhou";
        // Obtain access credentials from environment variables. Before you run this sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // The bucket name.
        String bucketName = "examplebucket";
        // The name of the destination animated GIF file.
        String targetKey = "dest.gif";
        // The name of the source video file.
        String sourceKey = "src.mp4";

        // Create an OSSClient instance.
        // When the OSSClient instance is no longer needed, call the shutdown method to release its resources.
        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            // Build a style string that contains the parameters for video-to-animated-image conversion.
            String style = String.format("video/animation,f_gif,w_100,h_100,inter_1000");
            // Build the asynchronous processing instruction.
            String bucketEncoded = Base64.getUrlEncoder().withoutPadding().encodeToString(bucketName.getBytes());
            String targetEncoded = Base64.getUrlEncoder().withoutPadding().encodeToString(targetKey.getBytes());
            String process = String.format("%s|sys/saveas,b_%s,o_%s/notify,topic_QXVkaW9Db252ZXJ0", style, bucketEncoded, targetEncoded);
            // Create an AsyncProcessObjectRequest object.
            AsyncProcessObjectRequest request = new AsyncProcessObjectRequest(bucketName, sourceKey, process);
            // Execute the asynchronous processing task.
            AsyncProcessObjectResult response = ossClient.asyncProcessObject(request);
            System.out.println("EventId: " + response.getEventId());
            System.out.println("RequestId: " + response.getRequestId());
            System.out.println("TaskId: " + response.getTaskId());

        } finally {
            // Shut down the OSSClient instance.
            ossClient.shutdown();
        }
    }
}

# -*- coding: utf-8 -*-
import base64
import oss2
from oss2.credentials import EnvironmentVariableCredentialsProvider

def main():
    # Obtain access credentials from environment variables. Before you run this sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    # The endpoint of the region in which the bucket is located. For example, if the bucket is in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com.
    endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
    # The region ID, for example, cn-hangzhou.
    region = 'cn-hangzhou'

    # The bucket name, for example, examplebucket.
    bucket = oss2.Bucket(auth, endpoint, 'examplebucket', region=region)

    # The name of the source video file.
    source_key = 'src.mp4'

    # The name of the destination animated GIF file.
    target_key = 'example.gif'

    # Define the parameters for converting the video to an animated GIF, such as width, height, and frame interval.
    animation_style = 'video/animation,f_gif,w_100,h_100,inter_1000'

    # Build the processing instruction, including the save path and the Base64-encoded bucket name and target object name.
    bucket_name_encoded = base64.urlsafe_b64encode('examplebucket'.encode()).decode().rstrip('=')
    target_key_encoded = base64.urlsafe_b64encode(target_key.encode()).decode().rstrip('=')
    process = f"{animation_style}|sys/saveas,b_{bucket_name_encoded},o_{target_key_encoded}/notify,topic_QXVkaW9Db252ZXJ0"

    try:
        # Execute the asynchronous processing task.
        result = bucket.async_process_object(source_key, process)
        print(f"EventId: {result.event_id}")
        print(f"RequestId: {result.request_id}")
        print(f"TaskId: {result.task_id}")
    except Exception as e:
        print(f"Error: {e}")

if __name__ == "__main__":
    main()

package main

import (
    "encoding/base64"
    "fmt"
    "os"
    "github.com/aliyun/aliyun-oss-go-sdk/oss"
    "log"
)

func main() {
    // Obtain access credentials from environment variables. Before you run this sample code, make sure that the OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET environment variables are configured.
    provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
    }
    // Create an OSSClient instance.
    // Specify the endpoint of the bucket. For example, for a bucket in the China (Hangzhou) region, set the endpoint to https://oss-cn-hangzhou.aliyuncs.com. For other regions, specify the actual endpoint.
    // Specify the region ID, for example, cn-hangzhou.
    client, err := oss.New("https://oss-cn-hangzhou.aliyuncs.com", "", "", oss.SetCredentialsProvider(&provider), oss.AuthVersion(oss.AuthV4), oss.Region("cn-hangzhou"))
    if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
    }
    // The bucket name, for example, examplebucket.
    bucketName := "examplebucket"

    bucket, err := client.Bucket(bucketName)
    if err != nil {
    fmt.Println("Error:", err)
    os.Exit(-1)
    }

    // The name of the source video file.
    sourceKey := "src.mp4"
    // The name of the destination animated GIF file.
    targetKey := "destexample.gif"

    // Define the parameters for converting the video to an animated GIF, such as width, height, and frame interval.
    animationStyle := "video/animation,f_gif,w_100,h_100,inter_1000"

    // Build the processing instruction, including the save path and the Base64-encoded bucket name and target object name.
    bucketNameEncoded := base64.URLEncoding.EncodeToString([]byte(bucketName))
    targetKeyEncoded := base64.URLEncoding.EncodeToString([]byte(targetKey))
    process := fmt.Sprintf("%s|sys/saveas,b_%v,o_%v/notify,topic_QXVkaW9Db252ZXJ0", animationStyle, bucketNameEncoded, targetKeyEncoded)

    // Execute the asynchronous processing task.
    result, err := bucket.AsyncProcessObject(sourceKey, process)
    if err != nil {
    log.Fatalf("Failed to async process object: %s", err)
    }

    fmt.Printf("EventId: %s\n", result.EventId)
    fmt.Printf("RequestId: %s\n", result.RequestId)
    fmt.Printf("TaskId: %s\n", result.TaskId)
}

Parâmetros

Ação: video/animation

A tabela a seguir descreve os parâmetros.

Exemplos de requisição

// Convert the example.mkv file into an animated image.
POST /example.mkv?x-oss-async-process HTTP/1.1
Host: video-demo.oss-cn-hangzhou.aliyuncs.com
Date: Fri, 28 Oct 2022 06:40:10 GMT
Authorization: OSS4-HMAC-SHA256 Credential=LTAI********************/20250417/cn-hangzhou/oss/aliyun_v4_request,Signature=a7c3554c729d71929e0b84489addee6b2e8d5cb48595adfc51868c299c0c218e
 
x-oss-async-process=video/animation,f_gif,w_100,h_100,inter_1000|sys/saveas,b_b3V0YnVja2V0,o_b3V0b2JqcHJlZml4LnthdXRvZXh0fQ/notify,topic_QXVkaW9Db252ZXJ0

// Convert the example.mkv file into an animated image.
POST /example.mkv?x-oss-async-process HTTP/1.1
Host: video-demo.oss-cn-hangzhou.aliyuncs.com
Date: Fri, 28 Oct 2022 06:40:10 GMT
Authorization: OSS4-HMAC-SHA256 Credential=LTAI********************/20250417/cn-hangzhou/oss/aliyun_v4_request,Signature=a7c3554c729d71929e0b84489addee6b2e8d5cb48595adfc51868c299c0c218e
 
x-oss-async-process=video/animation,ss_5000,f_webp,pw_25,ph_25,fps_25,inter_500|sys/saveas,b_b3V0YnVja2V0,o_b3V0b2JqcHJlZml4LnthdXRvZXh0fQ/notify,topic_QXVkaW9Db252ZXJ0

Faturamento

A conversão de vídeo para imagem animada gera cobranças tanto do OSS quanto do IMM. Os itens faturáveis incluem:

• OSS: Para obter mais informações sobre preços, consulte Preços do OSS.

  API	Item faturável	Descrição
  GetObject	Requisições GET	As taxas de requisição são calculadas com base no número de requisições bem-sucedidas.
  	Tráfego de saída pela internet	Se você chamar a operação GetObject usando um endpoint público (por exemplo, oss-cn-hangzhou.aliyuncs.com) ou um endpoint de aceleração de transferência (por exemplo, oss-accelerate.aliyuncs.com), será cobrado pelo tráfego de saída pela internet com base no volume de dados.
  	Recuperação de dados do armazenamento de Acesso Infrequente (IA)	Se você recuperar objetos de Acesso Infrequente (IA), será cobrado pelas taxas de recuperação de dados com base na quantidade de dados recuperados.
  	Recuperação de dados para leitura direta de arquivo	Se você ler objetos Archive de um bucket com leitura direta de arquivo ativada, será cobrado pelas taxas de recuperação de dados com base na quantidade de dados recuperados.
  	Aceleração de transferência	Se você ativar a aceleração de transferência e usar um endpoint de aceleração de transferência para acessar seu bucket, será cobrado pelas taxas de aceleração de transferência com base no volume de dados.
  PutObject	Requisições PUT	As taxas de requisição são calculadas com base no número de requisições bem-sucedidas.
  	Taxas de armazenamento	As taxas de armazenamento são cobradas com base na classe, no tamanho e na duração de armazenamento do objeto.
  HeadObject	Requisições GET	As taxas de requisição são calculadas com base no número de requisições bem-sucedidas.

• IMM: Para obter mais informações sobre preços, consulte IMM billing items.

  Importante

  A partir das 11:00 (UTC+8) de 28 de julho de 2025, o recurso de conversão de vídeo para imagem animada do IMM será atualizado de um service gratuito para um service pago. O item faturável é MediaAnimation. Para obter mais informações, consulte o anúncio de ajuste de faturamento do IMM.

  API	Item faturável	Descrição
  CreateMediaConvertTask	MediaAnimation	As taxas de conversão de vídeo para imagem animada são calculadas com base no número de quadros na imagem animada de saída.

Observações de uso

• A conversão de vídeo para imagem animada suporta apenas processamento assíncrono (usando o método x-oss-async-process).

• O acesso anônimo será negado.