视频变高清接口

# -*- coding: utf-8 -*-
import time
import requests
import json
import os

api_key = '******'  # 你的API KEY
file_path = '...'  # 视频路径

url = 'http(s)://api.shiliuai.com/api/video_super_resolution/v1'
headers = {'APIKEY': api_key}
data = {
    "size": 1080  # 处理后视频短边长度（像素）
}

# 提交任务
with open(file_path, "rb") as file:
    response = requests.post(url=url, headers=headers, files={"file": file}, data=data)

response = json.loads(response.content)
code = response.get('code')

if code == 0:
    file_id = response.get('file_id')

    # 轮询等待结果，处理完成后下载（同步等待）
    while True:
        wait_time = response.get('wait_time') or 1
        time.sleep(wait_time)

        response = requests.post(url=url, headers=headers, data={"file_id": file_id})
        response = json.loads(response.content)
        status = response.get('status')

        if status == 'done':
            result_url = response.get('result_url')
            video = requests.get(url=result_url)
            if video.status_code == 200:
                filename = os.path.basename(result_url)
                with open(filename, "wb") as f:
                    f.write(video.content)
                print('视频变高清成功，已保存', filename)
            else:
                print('下载失败:', video.status_code)
            break
else:
    print('请求失败:', response.get('msg_cn', response.get('msg')))

<?php
$url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1";
$apikey = "******";
$header = array();
array_push($header, "APIKEY:" . $apikey);

$file_path = "...";
$curl = curl_init();
curl_setopt($curl, CURLOPT_URL, $url);
curl_setopt($curl, CURLOPT_HTTPHEADER, $header);
curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
curl_setopt($curl, CURLOPT_SSL_VERIFYPEER, false);
curl_setopt($curl, CURLOPT_SSL_VERIFYHOST, false);

// 提交任务
$post_data = array(
    "file" => new CURLFile($file_path),
    "size" => 1080
);
curl_setopt($curl, CURLOPT_POSTFIELDS, $post_data);
$response = curl_exec($curl);
$response = json_decode($response, true);

if ($response['code'] == 0) {
    $file_id = $response['file_id'];

    // 轮询等待结果，处理完成后下载（同步等待）
    while (true) {
        $wait_time = isset($response['wait_time']) ? $response['wait_time'] : 1;
        sleep((int)$wait_time);

        $poll_data = array("file_id" => $file_id);
        curl_setopt($curl, CURLOPT_POSTFIELDS, $poll_data);
        $response = curl_exec($curl);
        $response = json_decode($response, true);

        if (isset($response['status']) && $response['status'] === 'done') {
            $result_url = $response['result_url'];
            $video_content = file_get_contents($result_url);
            $filename = basename($result_url);
            file_put_contents($filename, $video_content);
            echo "视频变高清成功，已保存 " . $filename;
            break;
        }
    }
}
var_dump($response);

import java.io.*;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.file.Files;
import org.json.JSONObject;

public class VideoSuperResolutionApiExample {
    public static void main(String[] args) {
        String apiKey = "******";
        String filePath = "...";
        String apiUrl = "http(s)://api.shiliuai.com/api/video_super_resolution/v1";

        try {
            // 提交任务（multipart/form-data）
            JSONObject response = submitTask(apiUrl, apiKey, filePath);
            if (response.getInt("code") != 0) {
                System.out.println("请求失败: " + response.optString("msg_cn", response.optString("msg")));
                return;
            }
            String fileId = response.getString("file_id");

            // 轮询等待结果，处理完成后下载（同步等待）
            while (true) {
                double waitTime = response.optDouble("wait_time", 1.0);
                Thread.sleep((long) (waitTime * 1000));

                response = fetchResult(apiUrl, apiKey, fileId);

                if ("done".equals(response.optString("status"))) {
                    downloadResult(response.getString("result_url"));
                    System.out.println("视频变高清成功");
                    break;
                }
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 提交任务：multipart/form-data 上传视频文件
    private static JSONObject submitTask(String apiUrl, String apiKey, String filePath) throws Exception {
        String boundary = "----FormBoundary" + System.currentTimeMillis();
        HttpURLConnection conn = openMultipartPost(apiUrl, apiKey, boundary);
        try (OutputStream os = conn.getOutputStream()) {
            os.write(("--" + boundary + "\r\n").getBytes());
            os.write(("Content-Disposition: form-data; name=\"file\"; filename=\""
                    + new File(filePath).getName() + "\"\r\n").getBytes());
            os.write(("Content-Type: application/octet-stream\r\n\r\n").getBytes());
            Files.copy(new File(filePath).toPath(), os);
            os.write(("\r\n").getBytes());
            os.write(("--" + boundary + "\r\n").getBytes());
            os.write(("Content-Disposition: form-data; name=\"size\"\r\n\r\n").getBytes());
            os.write(("1080\r\n").getBytes());
            os.write(("--" + boundary + "--\r\n").getBytes());
        }
        return readJson(conn);
    }

    // 查询任务结果
    private static JSONObject fetchResult(String apiUrl, String apiKey, String fileId) throws Exception {
        String boundary = "----FormBoundary" + System.currentTimeMillis();
        HttpURLConnection conn = openMultipartPost(apiUrl, apiKey, boundary);
        try (OutputStream os = conn.getOutputStream()) {
            os.write(("--" + boundary + "\r\n").getBytes());
            os.write(("Content-Disposition: form-data; name=\"file_id\"\r\n\r\n").getBytes());
            os.write((fileId + "\r\n").getBytes());
            os.write(("--" + boundary + "--\r\n").getBytes());
        }
        return readJson(conn);
    }

    private static HttpURLConnection openMultipartPost(String apiUrl, String apiKey, String boundary)
            throws Exception {
        HttpURLConnection conn = (HttpURLConnection) new URL(apiUrl).openConnection();
        conn.setRequestMethod("POST");
        conn.setRequestProperty("APIKEY", apiKey);
        conn.setRequestProperty("Content-Type", "multipart/form-data; boundary=" + boundary);
        conn.setDoOutput(true);
        return conn;
    }

    private static JSONObject readJson(HttpURLConnection conn) throws Exception {
        StringBuilder sb = new StringBuilder();
        try (BufferedReader br = new BufferedReader(
                new InputStreamReader(conn.getInputStream(), "utf-8"))) {
            String line;
            while ((line = br.readLine()) != null) sb.append(line.trim());
        }
        return new JSONObject(sb.toString());
    }

    // 下载结果视频
    private static void downloadResult(String resultUrl) throws Exception {
        try (InputStream is = new URL(resultUrl).openStream();
             FileOutputStream fos = new FileOutputStream(
                     new File(new URL(resultUrl).getPath()).getName())) {
            byte[] buffer = new byte[4096];
            int read;
            while ((read = is.read(buffer)) != -1) {
                fos.write(buffer, 0, read);
            }
        }
    }
}

const fs = require('fs');
const path = require('path');

const apiKey = '******';
const filePath = '...';
const apiUrl = 'http(s)://api.shiliuai.com/api/video_super_resolution/v1';

function sleep(seconds) {
  return new Promise(resolve => setTimeout(resolve, seconds * 1000));
}

async function main() {
  // 提交任务（multipart/form-data）
  const fileContent = fs.readFileSync(filePath);
  const boundary = '----FormBoundary' + Date.now();
  const body = [
    `--${boundary}`,
    'Content-Disposition: form-data; name="file"; filename="' + path.basename(filePath) + '"',
    'Content-Type: application/octet-stream',
    '',
    fileContent,
    `--${boundary}`,
    'Content-Disposition: form-data; name="size"',
    '',
    '1080',
    `--${boundary}--`,
  ].map(p => typeof p === 'string' ? Buffer.from(p + '\r\n', 'utf-8') : p);

  let res = await fetch(apiUrl, {
    method: 'POST',
    headers: { APIKEY: apiKey, 'Content-Type': `multipart/form-data; boundary=${boundary}` },
    body: Buffer.concat(body)
  });

  let data = await res.json();
  if (data.code !== 0) {
    console.error('请求失败:', data.msg_cn || data.msg);
    return;
  }

  const fileId = data.file_id;

  // 轮询等待结果，处理完成后下载（同步等待）
  while (true) {
    await sleep(data.wait_time || 1);

    const pollBoundary = '----FormBoundary' + Date.now();
    const pollBody = [
      `--${pollBoundary}`,
      'Content-Disposition: form-data; name="file_id"',
      '',
      fileId,
      `--${pollBoundary}--`,
    ].map(p => typeof p === 'string' ? Buffer.from(p + '\r\n', 'utf-8') : p);

    res = await fetch(apiUrl, {
      method: 'POST',
      headers: { APIKEY: apiKey, 'Content-Type': `multipart/form-data; boundary=${pollBoundary}` },
      body: Buffer.concat(pollBody)
    });

    data = await res.json();
    if (data.status === 'done') {
      // 下载结果视频
      const resultUrl = data.result_url;
      const dlRes = await fetch(resultUrl);
      if (dlRes.ok) {
        const buffer = Buffer.from(await dlRes.arrayBuffer());
        const filename = path.basename(resultUrl);
        fs.writeFileSync(filename, buffer);
        console.log('视频变高清成功，已保存', filename);
      }
      break;
    }
  }
}

main().catch(console.error);

const fs = require('fs');
const path = require('path');
const FormData = require('form-data');

const apiKey = '******';
const filePath = '...';
const apiUrl = 'http(s)://api.shiliuai.com/api/video_super_resolution/v1';

function sleep(seconds) {
  return new Promise(resolve => setTimeout(resolve, seconds * 1000));
}

async function main() {
  // 提交任务
  let form = new FormData();
  form.append('file', fs.createReadStream(filePath));
  form.append('size', '1080');

  let res = await fetch(apiUrl, {
    method: 'POST',
    headers: { APIKEY: apiKey, ...form.getHeaders() },
    body: form
  });

  let data = await res.json();
  if (data.code !== 0) {
    console.error('请求失败:', data.msg_cn || data.msg);
    return;
  }

  const fileId = data.file_id;

  // 轮询等待结果，处理完成后下载（同步等待）
  while (true) {
    await sleep(data.wait_time || 1);

    form = new FormData();
    form.append('file_id', fileId);

    res = await fetch(apiUrl, {
      method: 'POST',
      headers: { APIKEY: apiKey, ...form.getHeaders() },
      body: form
    });

    data = await res.json();
    if (data.status === 'done') {
      // 下载结果视频
      const resultUrl = data.result_url;
      const dlRes = await fetch(resultUrl);
      if (dlRes.ok) {
        const buffer = Buffer.from(await dlRes.arrayBuffer());
        const filename = path.basename(resultUrl);
        fs.writeFileSync(filename, buffer);
        console.log('视频变高清成功，已保存', filename);
      }
      break;
    }
  }
}

main().catch(console.error);

# 同步：提交任务后在本地轮询等待，直到处理完成再下载结果
# 1. 提交任务（返回 file_id 与 wait_time）
curl -k 'http(s)://api.shiliuai.com/api/video_super_resolution/v1' \
  -H 'APIKEY: 你的APIKEY' \
  -F 'file=@/path/to/video.mp4' \
  -F 'size=1080'

# 2. 轮询结果：将 file_id 替换为上一步返回值，按 wait_time 间隔重复请求，直到 status 为 done
curl -k 'http(s)://api.shiliuai.com/api/video_super_resolution/v1' \
  -H 'APIKEY: 你的APIKEY' \
  -F 'file_id=上一步返回的file_id'

# 3. 下载结果视频（status 为 done 时，使用返回的 result_url）
curl -k -O 'https://cdn.shiliuai.com/result/xxx.mp4'

using System;
using System.IO;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string apiKey = "******";
        string filePath = "...";
        string apiUrl = "http(s)://api.shiliuai.com/api/video_super_resolution/v1";

        using (HttpClient client = new HttpClient())
        {
            client.DefaultRequestHeaders.Add("APIKEY", apiKey);

            // 提交任务（multipart/form-data）
            string fileId;
            double waitTime;
            using (var content = new MultipartFormDataContent())
            {
                var fileBytes = await File.ReadAllBytesAsync(filePath);
                var fileContent = new ByteArrayContent(fileBytes);
                content.Add(fileContent, "file", Path.GetFileName(filePath));
                content.Add(new StringContent("1080"), "size");

                var response = await client.PostAsync(apiUrl, content);
                var responseObject = JsonSerializer.Deserialize<JsonElement>(
                    await response.Content.ReadAsStringAsync());

                if (responseObject.GetProperty("code").GetInt32() != 0)
                {
                    Console.WriteLine("请求失败: " + responseObject.GetProperty("msg_cn").GetString());
                    return;
                }

                fileId = responseObject.GetProperty("file_id").GetString();
                waitTime = responseObject.TryGetProperty("wait_time", out var wt) ? wt.GetDouble() : 1.0;
            }

            // 轮询等待结果，处理完成后下载（同步等待）
            while (true)
            {
                await Task.Delay((int)(waitTime * 1000));

                var pollContent = new MultipartFormDataContent();
                pollContent.Add(new StringContent(fileId), "file_id");
                var response = await client.PostAsync(apiUrl, pollContent);
                var responseObject = JsonSerializer.Deserialize<JsonElement>(
                    await response.Content.ReadAsStringAsync());

                if (responseObject.GetProperty("status").GetString() == "done")
                {
                    string resultUrl = responseObject.GetProperty("result_url").GetString();
                    var videoBytes = await client.GetByteArrayAsync(resultUrl);
                    string filename = Path.GetFileName(new Uri(resultUrl).LocalPath);
                    await File.WriteAllBytesAsync(filename, videoBytes);
                    Console.WriteLine("视频变高清成功，已保存 " + filename);
                    break;
                }

                waitTime = responseObject.TryGetProperty("wait_time", out var wt2) ? wt2.GetDouble() : 1.0;
            }
        }
    }
}

版本 2
.支持库 spec
.支持库 dp1

.子方法 视频变高清_API_示例
.局部变量 局_网址, 文本型
.局部变量 局_提交协议头, 文本型
.局部变量 局_结果, 字节集
.局部变量 局_返回, 文本型
.局部变量 视频数据, 字节集
.局部变量 file_id, 文本型
.局部变量 wait_time, 小数型

视频数据 ＝ 读入文件 ("你的视频路径.mp4")
局_网址 ＝ "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
局_提交协议头 ＝ "APIKEY: 你的APIKEY"

' 提交任务
局_结果 ＝ 网页_访问_对象 (局_网址, 1, , 视频数据, , 局_提交协议头, , , , , , , , , , , , , )
局_返回 ＝ 到文本 (编码_编码转换对象 (局_结果, , , ))

' 轮询等待结果（同步等待），status 为 done 时下载 result_url
.判断循环 (真)
    程序_延时 (wait_time × 1000, )
    局_结果 ＝ 网页_访问_对象 (局_网址, 1, "file_id=" ＋ file_id, , , 局_提交协议头, , , , , , , , , , , , , )
    局_返回 ＝ 到文本 (编码_编码转换对象 (局_结果, , , ))
.判断循环结束 ()
返回 (局_返回)

public static string Api_VideoSuperResolution(string apiKey, string videoPath)
{
    string url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1";
    var headers = new Dictionary<string, string>
    {
        {"APIKEY", apiKey}
    };
    // 使用 multipart/form-data 上传视频文件
    var files = new Dictionary<string, string>
    {
        {"file", videoPath}
    };
    var formData = new Dictionary<string, string>
    {
        {"size", "1080"}
    };
    // 提交任务并轮询等待结果（同步等待），status 为 done 时下载 result_url
    string response = CustomHelp.HttpPostMultipart(url, files, formData, headers);
    // 解析返回中的 file_id，按 wait_time 间隔循环查询
    return response;
}

Import "Encrypt.dll"

VBSBegin
' 启用错误处理
On Error Resume Next

Function api_video_super_resolution(apiKey, videoPath)
    ' 先检查文件是否存在,避免后续错误
    Dim fso
    Set fso = CreateObject("Scripting.FileSystemObject")
    If Not fso.FileExists(videoPath) Then
        api_video_super_resolution = "ERROR: 视频文件不存在 - " & videoPath
        Exit Function
    End If

    url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
    Set http = CreateObject("MSXML2.XMLHTTP")
    http.Open "POST", url, False
    http.setRequestHeader "APIKEY", apiKey
    ' multipart/form-data 上传视频文件
    Dim boundary : boundary = "------FormBoundary" & Timer
    http.setRequestHeader "Content-Type", "multipart/form-data; boundary=" & boundary
    ' 读取视频文件并构造 multipart body
    Dim inFile : Set inFile = fso.GetFile(videoPath)
    Dim ts : Set ts = inFile.OpenAsTextStream(1, -2)
    Dim fileData : fileData = ts.Read(inFile.Size)
    ts.Close
    Dim body : body = "--" & boundary & vbCrLf
    body = body & "Content-Disposition: form-data; name=""file""; filename=""" & inFile.Name & """" & vbCrLf
    body = body & "Content-Type: application/octet-stream" & vbCrLf & vbCrLf
    body = body & fileData & vbCrLf
    body = body & "--" & boundary & vbCrLf
    body = body & "Content-Disposition: form-data; name=""size""" & vbCrLf & vbCrLf
    body = body & "1080" & vbCrLf
    body = body & "--" & boundary & "--" & vbCrLf

    ' 发送请求
    On Error Resume Next ' 再次确保捕获网络错误
    http.send body

    If Err.Number <> 0 Then
        api_video_super_resolution = "HTTP发送错误: " & Err.Description
        Err.Clear
        Exit Function
    End If

    ' 检查HTTP状态
    If http.Status <> 200 Then
        api_video_super_resolution = "HTTP状态异常: " & http.Status & " - " & http.statusText
        Exit Function
    End If

    responseText = http.responseText
    ' 同步等待：解析 file_id 后循环轮询，status 为 done 时下载 result_url
    Do
        WScript.Sleep 1200
        jsonBody = "{" & Chr(34) & "file_id" & Chr(34) & ":" & Chr(34) & "上一步返回的file_id" & Chr(34) & "}"
        http.send jsonBody
        responseText = http.responseText
        ' status 为 done 时结束循环
    Loop

    api_video_super_resolution = responseText
    Set http = Nothing
    Set ts = Nothing
    Set inFile = Nothing
    Set fso = Nothing
End Function
VBSEnd

' 主程序部分
apiKey = "你的APIKEY"   ' 请替换为真实APIKEY
videoPath = "你的视频路径.mp4"   ' 请替换为真实视频路径

res = api_video_super_resolution(apiKey, videoPath)

' 输出结果,如果出错则显示错误信息
If Left(res, 5) = "ERROR" Or Left(res, 6) = "HTTP状态" Or Left(res, 5) = "HTTP发" Then
    TracePrint "【错误】" & res
Else
    TracePrint "【响应】" & res
End If

Import "yd.luae"
Import "zm.luae"

Dim videoPath = "/sdcard/Pictures/test.mp4"

' 同步：提交任务后轮询等待，处理完成后下载结果
Function api_video_super_resolution(apiKey, videoPath)
    Dim url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
    Dim headers = {null}
    headers["APIKEY"] = apiKey
    Dim body = "{""file_url"":""" & videoPath & """,""size"":1080}"
    Dim res = yd.HttpPost(url, body, headers)
    Dim data = yd.JsonDecode(res)
    Dim fileId = data["file_id"]

    ' 轮询等待结果（同步等待），status 为 done 时下载 result_url
    Do
        Delay data["wait_time"] * 1000
        Dim pollBody = "{""file_id"":""" & fileId & """}"
        res = yd.HttpPost(url, pollBody, headers)
        data = yd.JsonDecode(res)
    Loop While data["status"] <> "done"

    Dim resultUrl = data["result_url"]
    yd.DownloadFile(resultUrl, "/sdcard/Pictures/result.mp4")
    api_video_super_resolution = data
End Function

Dim apiKey = "你的APIKEY"
Dim res = api_video_super_resolution(apiKey, videoPath)
TracePrint res["code"]

require("tsnet")
require "TSLib"
local ts = require("ts")
local json = ts.json

-- 同步：提交任务后轮询等待，处理完成后下载结果
function api_video_super_resolution(apiKey, videoPath)
    local url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
    local headers = {}
    headers["APIKEY"] = apiKey
    headers["Content-Type"] = "application/json"
    local body = json.encode({ file_url = videoPath, size = 1080 })
    local resp = httpPost(url, body, { headers = headers })
    local data = json.decode(resp)
    local fileId = data.file_id

    -- 轮询等待结果（同步等待），status 为 done 时下载 result_url
    while true do
        mSleep((data.wait_time or 1) * 1000)
        local pollBody = json.encode({ file_id = fileId })
        local pollResp = httpPost(url, pollBody, { headers = headers })
        data = json.decode(pollResp)
        if data.status == "done" then
            -- 下载结果视频
            local resultUrl = data.result_url
            local res = httpGet(resultUrl)
            if res then
                local filename = string.match(resultUrl, "([^/]+)$")
                writeFile("/var/mobile/Media/" .. filename, res)
            end
            return data
        end
    end
end

local apiKey = "你的APIKEY"
local videoPath = "/var/mobile/Media/test.mp4"
local data = api_video_super_resolution(apiKey, videoPath)

-- 同步：提交任务后轮询等待，处理完成后下载结果
function api_video_super_resolution(apiKey, videoPath)
    local url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
    local headers = {}
    headers["APIKEY"] = apiKey
    headers["Content-Type"] = "application/json"
    local body = jsonLib.encode({ file_url = videoPath, size = 1080 })
    local resp = httpPost(url, body, { headers = headers })
    local data = jsonLib.decode(resp)
    local fileId = data.file_id

    -- 轮询等待结果（同步等待），status 为 done 时下载 result_url
    while true do
        sleep((data.wait_time or 1) * 1000)
        local pollBody = jsonLib.encode({ file_id = fileId })
        local pollResp = httpPost(url, pollBody, { headers = { ["APIKEY"] = apiKey, ["Content-Type"] = "application/json" } })
        data = jsonLib.decode(pollResp)
        if data.status == "done" then
            downloadFile(data.result_url, "/sdcard/Pictures/result.mp4")
            return data
        end
    end
end

local apiKey = "你的APIKEY"
local videoPath = "/sdcard/Pictures/test.mp4"
local data = api_video_super_resolution(apiKey, videoPath)

-- 同步：提交任务后轮询等待，处理完成后下载结果
function api_video_super_resolution(apiKey, videoPath)
    local url = "http(s)://api.shiliuai.com/api/video_super_resolution/v1"
    local headers = {
        ["APIKEY"] = apiKey,
        ["Content-Type"] = "application/json"
    }
    local body = JSON.stringify({ file_url = videoPath, size = 1080 })
    local params = {
        url = url,
        method = "POST",
        headers = headers,
        requestBody = body
    }
    local res = http.request(params)
    local data = JSON.parse(res.body)
    local fileId = data.file_id

    -- 轮询等待结果（同步等待），status 为 done 时下载 result_url
    while true do
        sleep((data.wait_time or 1) * 1000)
        params.requestBody = JSON.stringify({ file_id = fileId })
        res = http.request(params)
        data = JSON.parse(res.body)
        if data.status == "done" then
            logd("视频变高清成功: " .. tostring(data.result_url))
            return data
        end
    end
end

function main()
    local apiKey = "你的APIKEY"
    local videoPath = "/sdcard/Pictures/test.mp4"
    local data = api_video_super_resolution(apiKey, videoPath)
    if data then
        logd(data.status)
    end
end

main()