Video Enhancement

                                        
import requests
import json

# API configuration
url_base = "https://api.hitpaw.com/api/v3"
api_key = "YOUR_API_KEY"
headers = {
    "Content-Type": "application/json",
    "ApiKey": api_key
}

# Enhancement request
def enhance_video():
    url = f"{url_base}/video-enhancer/export"
    payload = {
        "video_url": "https://example.com/video.mp4",
        "extension": ".mp4",
        "model_id": 17,
        "resolution": [1920, 1080],
        "web_hook_url": "https://your-server.com/webhook"
    }

    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.json()

# Task status check
def check_task_status(job_id):
    url = f"{url_base}/video-enhancer-api/task"
    payload = {
        "job_id": job_id
    }

    response = requests.post(url, headers=headers, data=json.dumps(payload))
    return response.json()

# Usage example
enhancement_response = enhance_video()
print("Enhancement request:", enhancement_response)

if enhancement_response.get("code") == 200:
    job_id = enhancement_response["data"]["job_id"]
    status_response = check_task_status(job_id)
    print("Task status:", status_response)
                                    
                                

                                        
 "https://example.com/video.mp4",
        "extension" => ".mp4",
        "model_id" => 17,
        "resolution" => array(1920, 1080),
        "web_hook_url" => "https://your-server.com/webhook"
    );

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array(
        'Content-Type: application/json',
        'ApiKey: ' . $apiKey
    ));

    $response = curl_exec($ch);
    $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
    curl_close($ch);

    return json_decode($response, true);
}

// Task status check
function checkTaskStatus($jobId) {
    global $api_base_url, $apiKey;
    $url = $api_base_url . "/video-enhancer-api/task";

    $payload = array(
        "job_id" => $jobId
    );

    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($ch, CURLOPT_POST, true);
    curl_setopt($ch, CURLOPT_POSTFIELDS, json_encode($payload));
    curl_setopt($ch, CURLOPT_HTTPHEADER, array(
        'Content-Type: application/json',
        'ApiKey: ' . $apiKey
    ));

    $response = curl_exec($ch);
    curl_close($ch);

    return json_decode($response, true);
}

// Usage example
$enhancementResponse = enhanceVideo();
echo "Enhancement request: ";
print_r($enhancementResponse);

if ($enhancementResponse["code"] == 200) {
    $jobId = $enhancementResponse["data"]["job_id"];
    $statusResponse = checkTaskStatus($jobId);
    echo "Task status: ";
    print_r($statusResponse);
}
?>
                                    
                                

                                        
import java.io.BufferedReader;
import java.io.InputStreamReader;
import java.io.OutputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.nio.charset.StandardCharsets;

public class VideoEnhancerApiExample {
    private static final String API_BASE_URL = "https://api.hitpaw.com/api/v3";
    private static final String API_KEY = "YOUR_API_KEY";

    // Enhancement request
    public static String enhanceVideo() {
        try {
            URL url = new URL(API_BASE_URL + "/video-enhancer/export");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("ApiKey", API_KEY);
            conn.setDoOutput(true);

            String jsonInput = "{"
                + "\"video_url\": \"https://example.com/video.mp4\","
                + "\"extension\": \".mp4\","
                + "\"model_id\": 17,"
                + "\"resolution\": [1920, 1080],"
                + "\"web_hook_url\": \"https://your-server.com/webhook\""
                + "}";

            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = jsonInput.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            return readResponse(conn);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    // Task status check
    public static String checkTaskStatus(String jobId) {
        try {
            URL url = new URL(API_BASE_URL + "/video-enhancer-api/task");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("POST");
            conn.setRequestProperty("Content-Type", "application/json");
            conn.setRequestProperty("ApiKey", API_KEY);
            conn.setDoOutput(true);

            String jsonInput = "{\"job_id\": \"" + jobId + "\"}";

            try (OutputStream os = conn.getOutputStream()) {
                byte[] input = jsonInput.getBytes(StandardCharsets.UTF_8);
                os.write(input, 0, input.length);
            }

            return readResponse(conn);
        } catch (Exception e) {
            e.printStackTrace();
            return null;
        }
    }

    private static String readResponse(HttpURLConnection conn) throws Exception {
        int responseCode = conn.getResponseCode();
        BufferedReader br;
        if (responseCode == HttpURLConnection.HTTP_OK) {
            br = new BufferedReader(new InputStreamReader(conn.getInputStream()));
        } else {
            br = new BufferedReader(new InputStreamReader(conn.getErrorStream()));
        }

        StringBuilder response = new StringBuilder();
        String responseLine;
        while ((responseLine = br.readLine()) != null) {
            response.append(responseLine);
        }
        br.close();

        return response.toString();
    }

    public static void main(String[] args) {
        // Enhancement request
        String enhancementResponse = enhanceVideo();
        System.out.println("Enhancement response: " + enhancementResponse);

        // Extract job_id from response and check status
        // This is a simplified example - use a JSON parser in production
        if (enhancementResponse != null && enhancementResponse.contains("job_id")) {
            // Simple parsing for demonstration - use proper JSON parsing in production
            int startIdx = enhancementResponse.indexOf("job_id") + 9;
            int endIdx = enhancementResponse.indexOf("\"", startIdx);
            String jobId = enhancementResponse.substring(startIdx, endIdx);

            String statusResponse = checkTaskStatus(jobId);
            System.out.println("Task status: " + statusResponse);
        }
    }
}
                                    
                                

                                        
const apiBaseUrl = 'https://api.hitpaw.com/api/v3';
const apiKey = 'YOUR_API_KEY';

// Enhancement request
async function enhanceVideo() {
    const requestData = {
        video_url: 'https://example.com/video.mp4',
        extension: '.mp4',
        model_id: 17,
        resolution: [1920, 1080],
        web_hook_url: 'https://your-server.com/webhook'
    };

    try {
        const response = await fetch(`${apiBaseUrl}/video-enhancer/export`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'ApiKey': apiKey
            },
            body: JSON.stringify(requestData)
        });

        return await response.json();
    } catch (error) {
        console.error('Error:', error);
        return null;
    }
}

// Task status check
async function checkTaskStatus(jobId) {
    const requestData = {
        job_id: jobId
    };

    try {
        const response = await fetch(`${apiBaseUrl}/video-enhancer-api/task`, {
            method: 'POST',
            headers: {
                'Content-Type': 'application/json',
                'ApiKey': apiKey
            },
            body: JSON.stringify(requestData)
        });

        return await response.json();
    } catch (error) {
        console.error('Error:', error);
        return null;
    }
}

// Usage example
async function processVideo() {
    // Submit enhancement request
    const enhancementResponse = await enhanceVideo();
    console.log('Enhancement response:', enhancementResponse);

    if (enhancementResponse && enhancementResponse.code === 200) {
        const jobId = enhancementResponse.data.job_id;

        // Check task status
        const statusResponse = await checkTaskStatus(jobId);
        console.log('Task status:', statusResponse);

        // In real applications you may want to poll the status until completion
        // This is just a simple example
    }
}

processVideo();
                                    
                                

                                        
pa
import (
    "bytes"
    "encoding/json"
    "fmt"
    "io/ioutil"
    "net/http"
)

const (
    apiBaseURL = "https://api.hitpaw.com/api/v3"
    apiKey     = "YOUR_API_KEY"
)

// EnhanceVideo sends an enhancement request for a video
func enhanceVideo() (map[string]interface{}, error) {
    apiURL := apiBaseURL + "/video-enhancer/export"

    requestBody, err := json.Marshal(map[string]interface{}{
        "video_url":    "https://example.com/video.mp4",
        "extension":    ".mp4",
        "model_id":     17,
        "resolution":   []int{1920, 1080},
        "web_hook_url": "https://your-server.com/webhook",
    })
    if err != nil {
        return nil, fmt.Errorf("error creating request body: %v", err)
    }

    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(requestBody))
    if err != nil {
        return nil, fmt.Errorf("error creating request: %v", err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("error sending request: %v", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading response: %v", err)
    }

    var result map[string]interface{}
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, fmt.Errorf("error parsing response: %v", err)
    }

    return result, nil
}

// CheckTaskStatus Check task status
func checkTaskStatus(jobID string) (map[string]interface{}, error) {
    apiURL := apiBaseURL + "/video-enhancer-api/task"

    requestBody, err := json.Marshal(map[string]string{
        "job_id": jobID,
    })
    if err != nil {
        return nil, fmt.Errorf("error creating request body: %v", err)
    }

    req, err := http.NewRequest("POST", apiURL, bytes.NewBuffer(requestBody))
    if err != nil {
        return nil, fmt.Errorf("error creating request: %v", err)
    }

    req.Header.Set("Content-Type", "application/json")
    req.Header.Set("ApiKey", apiKey)

    client := &http.Client{}
    resp, err := client.Do(req)
    if err != nil {
        return nil, fmt.Errorf("error sending request: %v", err)
    }
    defer resp.Body.Close()

    body, err := ioutil.ReadAll(resp.Body)
    if err != nil {
        return nil, fmt.Errorf("error reading response: %v", err)
    }

    var result map[string]interface{}
    err = json.Unmarshal(body, &result)
    if err != nil {
        return nil, fmt.Errorf("error parsing response: %v", err)
    }

    return result, nil
}

func main() {
    // Enhancement request
    enhancementResult, err := enhanceVideo()
    if err != nil {
        fmt.Printf("Error enhancing video: %v\n", err)
        return
    }

    fmt.Println("Enhancement response:", enhancementResult)

    // Check whether it succeeded and get job_id
    if code, ok := enhancementResult["code"].(float64); ok && code == 200 {
        data, ok := enhancementResult["data"].(map[string]interface{})
        if !ok {
            fmt.Println("Error parsing response data")
            return
        }

        jobID, ok := data["job_id"].(string)
        if !ok {
            fmt.Println("Error retrieving job_id from response")
            return
        }

        // Check task status
        statusResult, err := checkTaskStatus(jobID)
        if err != nil {
            fmt.Printf("Error checking task status: %v\n", err)
            return
        }

        fmt.Println("Task status:", statusResult)
    }
}