Media upload

Initialize a client

Before you can use the SDK, initialize a client. For more information, see Initialization.

Create a URL and a credential for uploading videos

You can call the CreateUploadVideo operation to create a URL and a credential for uploading videos.

For more information about the request and response parameters of this operation, see CreateUploadVideo. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadVideo(client *vod.Client) (response *vod.CreateUploadVideoResponse, err error) {
    request := vod.CreateCreateUploadVideoRequest()

    request.Title = "Sample Video Title"
    request.Description = "Sample Description"
    request.FileName = "/opt/video/sample/video_file.mp4"
    //request.CateId = "-1"
    request.CoverURL = "http://192.168.0.0/16/tps/TB1qnJ1PVXXXXXCXXXXXXXXXXXX-700-700.png"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadVideo(request)
}


func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadVideo(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("VideoId: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.VideoId, response.UploadAddress, response.UploadAuth)
}

Refresh the credential for uploading videos

You can call the RefreshUploadVideo operation to refresh the credential for uploading videos.

For more information about the request and response parameters of this operation, see RefreshUploadVideo. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyRefreshUploadVideo(client *vod.Client) (response *vod.RefreshUploadVideoResponse, err error) {
    request := vod.CreateRefreshUploadVideoRequest()
    request.VideoId = "6657f89a86fa4f76a295ae95636e5aed"
    request.AcceptFormat = "JSON"

    return client.RefreshUploadVideo(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyRefreshUploadVideo(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("UploadAddress: %s\n UploadAuth: %s", response.UploadAddress, response.UploadAuth)
}

Create a URL and a credential for uploading images

You can call the CreateUploadImage operation to create a URL and a credential for uploading images.

For more information about the request and response parameters of this operation, see CreateUploadImage. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadImage(client *vod.Client) (response *vod.CreateUploadImageResponse, err error) {
    request := vod.CreateCreateUploadImageRequest()

    request.ImageType = "cover"
    request.ImageExt = "jpg"
    request.Title = "Sample Image Title"
    //request.CateId = "-1"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadImage(request)
}


func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadImage(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("ImageId: %s\n ImageURL: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.ImageId, response.ImageURL, response.UploadAddress, response.UploadAuth)
}

Create a URL and a credential for uploading attached media assets

You can call the CreateUploadAttachedMedia operation to create a URL and a credential for uploading attached media assets.

For more information about the request and response parameters of this operation, see CreateUploadAttachedMedia. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
)

func MyCreateUploadAttachedMedia(client *vod.Client) (response *vod.CreateUploadAttachedMediaResponse, err error) {
    request := vod.CreateCreateUploadAttachedMediaRequest()

    request.BusinessType = "watermark"
    request.MediaExt = "gif"
    request.Title = "Sample watermark Title"
    //request.CateId = "-1"
    request.Tags = "tag1,tag2"

    request.AcceptFormat = "JSON"
    return client.CreateUploadAttachedMedia(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyCreateUploadAttachedMedia(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Printf("MediaId: %s\n MediaURL: %s\n FileURL: %s\n UploadAddress: %s\n UploadAuth: %s",
        response.MediaId, response.MediaURL, response.FileURL, response.UploadAddress, response.UploadAuth)
}

Upload media files by using a source file URL

You can call the UploadMediaByURL operation to upload media files by using a source file URL.

For more information about the request and response parameters of this operation, see UploadMediaByURL. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "encoding/json"
    "net/url"
    "strings"
)

func MyUploadMediaByURL(client *vod.Client) (response *vod.UploadMediaByURLResponse, err error) {
    request := vod.CreateUploadMediaByURLRequest()

    // Encode URLs.
    sourceUrls := []string{"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample1.mp4",
        "https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.flv"}
    uploadUrls := []string{}
    metadatas := []map[string]interface{}{}
    for _, surl := range sourceUrls {
        encodeUrl := url.QueryEscape(surl)
        uploadUrls = append(uploadUrls, encodeUrl)
        metadata := map[string]interface{}{"SourceURL": encodeUrl, "Title":"UploadMediaByURL Sample Title"}
        metadatas = append(metadatas, metadata)
    }

    // The URLs that you want to use to upload media files. Separate multiple URLs with commas (,).
    request.UploadURLs = strings.Join(uploadUrls, ",")

    // Optional. The metadata that corresponds to the URLs.
    jsonMetas, err := json.Marshal(metadatas)
    if err ! = nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    request.UploadMetadatas = string(jsonMetas)

    // Optional. The transcoding template group.
    //request.TemplateGroupId = "<TemplateGroupId>"

    request.AcceptFormat = "JSON"
    return client.UploadMediaByURL(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyUploadMediaByURL(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    for _, job := range response.UploadJobs {
        fmt.Printf("%s: %s\n", job.JobId, job.SourceURL)
    }
}

Register media assets

You can call the RegisterMedia operation to register media assets.

For more information about the request and response parameters of this operation, see RegisterMedia. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "encoding/json"
)

func MyRegisterMedia(client *vod.Client) (response *vod.RegisterMediaResponse, err error) {
    request := vod.CreateRegisterMediaRequest()

    metadatas := []map[string]interface{}{}
    metadata1 := map[string]interface{}{"FileURL":"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample1.mp4",
        "Title":"RegisterMedia sample Title 1"}
    metadata2 := map[string]interface{}{"FileURL":"https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.mp4",
        "Title":"RegisterMedia sample Title 2"}
    metadatas = append(metadatas, metadata1, metadata2)
    jsonMetas, err := json.Marshal(metadatas)
    if err ! = nil {
        fmt.Println("json.Marshal failed:", err)
        return
    }
    request.RegisterMetadatas = string(jsonMetas)
    //request.TemplateGroupId = "<TemplateGroupId>"

    request.AcceptFormat = "JSON"
    return client.RegisterMedia(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyRegisterMedia(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Println(response.FailedFileURLs)
    fmt.Println(response.RegisteredMediaList)
}

Query URLs that are used to upload media files

You can call the GetURLUploadInfos operation to query URLs that are used to upload media files.

For more information about the request and response parameters of this operation, see GetURLUploadInfos. Example:

package main

import (
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk"
    "github.com/aliyun/alibaba-cloud-sdk-go/services/vod"
    "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials"
    "fmt"
    "strings"
)

func MyGetURLUploadInfos(client *vod.Client) (response *vod.GetURLUploadInfosResponse, err error) {
    request := vod.CreateGetURLUploadInfosRequest()

    // Encode URLs.
    sourceUrls := []string{"https://192.168.0.0/16/vod_sample1.mp4",
        "https://sample.oss-cn-shanghai.aliyuncs.com/vod_sample2.flv"}
    uploadUrls := []string{}
    for _, surl := range sourceUrls {
        encodeUrl := url.QueryEscape(surl)
        uploadUrls = append(uploadUrls, encodeUrl)
    }

    // The URLs that you want to use to upload media files. Separate multiple URLs with commas (,).
    request.UploadURLs = strings.Join(uploadUrls, ",")

    // The job IDs that you use to query URLs.
    //request.JobIds = "jobId1,jobId2"

    request.AcceptFormat = "JSON"
    return client.GetURLUploadInfos(request)
}

func main() {
    client, err := InitVodClient("<accessKeyId>", "<accessKeySecret>")
    if err ! = nil {
        panic(err)
    }

    response, err := MyGetURLUploadInfos(client)
    if err ! = nil {
        panic(err)
    }

    fmt.Println(response.GetHttpContentString())
    fmt.Println(response.NonExists)
    for _, uploadInfo := range response.URLUploadInfoList {
        fmt.Printf("%s: %s %s\n", uploadInfo.UploadURL, uploadInfo.Status, uploadInfo.MediaId)
    }
}