Object Storage Service:Concaténation vidéo

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 {
        // Replace with the endpoint for the region where your bucket is located.
        String endpoint = "https://oss-cn-hangzhou.aliyuncs.com";
        // Specify the region ID, such as cn-hangzhou.
        String region = "cn-hangzhou";
        // Read credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
        EnvironmentVariableCredentialsProvider credentialsProvider = CredentialsProviderFactory.newEnvironmentVariableCredentialsProvider();
        // Specify the bucket name.
        String bucketName = "examplebucket";
        // Specify the output video name.
        String targetObject = "dest.mp4";
        // Specify the source video (the main file used as the transcoding base).
        String sourceVideo = "src.mp4";
        // Specify the videos to prepend and append.
        String video1 = "concat1.mp4";
        String video2 = "concat2.mp4";

        ClientBuilderConfiguration clientBuilderConfiguration = new ClientBuilderConfiguration();
        clientBuilderConfiguration.setSignatureVersion(SignVersion.V4);
        OSS ossClient = OSSClientBuilder.create()
                .endpoint(endpoint)
                .credentialsProvider(credentialsProvider)
                .clientConfiguration(clientBuilderConfiguration)
                .region(region)
                .build();

        try {
            // Base64 URL-safe encode the video object names (required by the /pre and /sur parameters).
            String video1Encoded = Base64.getUrlEncoder().withoutPadding().encodeToString(video1.getBytes());
            String video2Encoded = Base64.getUrlEncoder().withoutPadding().encodeToString(video2.getBytes());

            // Build the processing style string:
            // - /pre,o_<encoded>: prepend video1 to the beginning
            // - /sur,o_<encoded>,t_0: append video2 to the end (t_0 means use the full clip)
            // - Other parameters control the output encoding.
            String style = String.format(
                "video/concat,ss_0,f_mp4,vcodec_h264,fps_25,vb_1000000,acodec_aac,ab_96000,ar_48000,ac_2,align_1" +
                "/pre,o_%s/sur,o_%s,t_0",
                video1Encoded, video2Encoded
            );

            // Append save-as and notification instructions.
            String bucketEncoded = Base64.getUrlEncoder().withoutPadding().encodeToString(bucketName.getBytes());
            String targetEncoded = Base64.getUrlEncoder().withoutPadding().encodeToString(targetObject.getBytes());
            String process = String.format(
                "%s|sys/saveas,b_%s,o_%s/notify,topic_QXVkaW9Db252ZXJ0",
                style, bucketEncoded, targetEncoded
            );

            // Submit the asynchronous task.
            AsyncProcessObjectRequest request = new AsyncProcessObjectRequest(bucketName, sourceVideo, process);
            AsyncProcessObjectResult response = ossClient.asyncProcessObject(request);
            System.out.println("EventId: " + response.getEventId());
            System.out.println("RequestId: " + response.getRequestId());
            System.out.println("TaskId: " + response.getTaskId());
        } finally {
            ossClient.shutdown();
        }
    }
}

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

def main():
    # Read credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
    auth = oss2.ProviderAuthV4(EnvironmentVariableCredentialsProvider())
    # Replace with the endpoint for the region where your bucket is located.
    endpoint = 'https://oss-cn-hangzhou.aliyuncs.com'
    region = 'cn-hangzhou'

    bucket = oss2.Bucket(auth, endpoint, 'examplebucket', region=region)

    # Specify the output video name.
    target_object = 'out.mp4'
    # Specify the source video (the main file used as the transcoding base).
    source_video = 'emrfinal.mp4'
    # Specify the videos to prepend and append.
    video1 = 'osshdfs.mp4'
    video2 = 'product.mp4'

    # Base64 URL-safe encode the video object names (required by the /pre and /sur parameters).
    video1_encoded = base64.urlsafe_b64encode(video1.encode()).decode().rstrip('=')
    video2_encoded = base64.urlsafe_b64encode(video2.encode()).decode().rstrip('=')

    # Build the processing style string:
    # - /pre,o_<encoded>: prepend video1 to the beginning
    # - /sur,o_<encoded>,t_0: append video2 to the end (t_0 means use the full clip)
    # - Other parameters control the output encoding.
    style = (
        f"video/concat,ss_0,f_mp4,vcodec_h264,fps_25,vb_1000000,acodec_aac,ab_96000,ar_48000,ac_2,align_1"
        f"/pre,o_{video1_encoded}/sur,o_{video2_encoded},t_0"
    )

    # Append save-as and notification instructions.
    bucket_encoded = base64.urlsafe_b64encode('examplebucket'.encode()).decode().rstrip('=')
    target_encoded = base64.urlsafe_b64encode(target_object.encode()).decode().rstrip('=')
    process = f"{style}|sys/saveas,b_{bucket_encoded},o_{target_encoded}/notify,topic_QXVkaW9Db252ZXJ0"

    # Submit the asynchronous task.
    try:
        result = bucket.async_process_object(source_video, 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"
    "strings"

    "github.com/aliyun/aliyun-oss-go-sdk/oss"
)

func main() {
    // Read credentials from environment variables OSS_ACCESS_KEY_ID and OSS_ACCESS_KEY_SECRET.
    provider, err := oss.NewEnvironmentVariableCredentialsProvider()
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

    // Replace yourEndpoint with the endpoint for the region where your bucket is located,
    // and yourRegion with the corresponding region ID (e.g., cn-hangzhou).
    client, err := oss.New(
        "yourEndpoint", "", "",
        oss.SetCredentialsProvider(&provider),
        oss.AuthVersion(oss.AuthV4),
        oss.Region("yourRegion"),
    )
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }

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

    // Specify the output video name.
    targetObject := "dest.mp4"
    // Specify the source video (the main file used as the transcoding base).
    sourcevideo := "src.mp4"
    // Specify the videos to prepend and append.
    video1 := "concat1.mp4"
    video2 := "concat2.mp4"

    // Base64 URL-safe encode the video object names (required by the /pre and /sur parameters).
    encode := func(s string) string {
        return strings.TrimRight(base64.URLEncoding.EncodeToString([]byte(s)), "=")
    }

    // Build the processing style string:
    // - /pre,o_<encoded>: prepend video1 to the beginning
    // - /sur,o_<encoded>,t_0: append video2 to the end (t_0 means use the full clip)
    // - Other parameters control the output encoding.
    style := fmt.Sprintf(
        "video/concat,ss_0,f_mp4,vcodec_h264,fps_25,vb_1000000,acodec_aac,ab_96000,ar_48000,ac_2,align_1/pre,o_%s/sur,o_%s,t_0",
        encode(video1), encode(video2),
    )

    // Append save-as and notification instructions.
    process := fmt.Sprintf(
        "%s|sys/saveas,b_%s,o_%s/notify,topic_QXVkaW9Db252ZXJ0",
        style, encode(bucketName), encode(targetObject),
    )

    // Submit the asynchronous task.
    rs, err := bucket.AsyncProcessObject(sourcevideo, process)
    if err != nil {
        fmt.Println("Error:", err)
        os.Exit(-1)
    }
    fmt.Printf("EventId: %s\n", rs.EventId)
    fmt.Printf("RequestId: %s\n", rs.RequestId)
    fmt.Printf("TaskId: %s\n", rs.TaskId)
}