Best practices for audio and video processing

Without GPU acceleration

Single output (1:1)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -i input.mp4 -c:v h264 -vf scale=1920:1080 -b:v 5M output.mp4

Multiple outputs (1:N)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -i input.mp4 \
  -c:a copy -c:v h264 -vf scale=1920:1080 -b:v 5M output_1080.mp4 \
  -c:a copy -c:v h264 -vf scale=1280:720  -b:v 5M output_720.mp4 \
  -c:a copy -c:v h264 -vf scale=640:480   -b:v 5M output_480.mp4

With GPU acceleration

Single output (1:1)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -hwaccel cuda -hwaccel_output_format cuda \
  -i input.mp4 -c:v h264_nvenc -vf scale_cuda=1920:1080:1:4 -b:v 5M output.mp4

Multiple outputs (1:N)

docker run --rm -it --volume $PWD:/workspace --runtime=nvidia willprice/nvidia-ffmpeg \
  -y -hwaccel cuda -hwaccel_output_format cuda -i input.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=1920:1080 -b:v 5M output_1080.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=1280:720  -b:v 5M output_720.mp4 \
  -c:a copy -c:v h264_nvenc -vf scale_npp=640:480   -b:v 5M output_480.mp4

Key parameters

Procedure

1. Create a project.

   s init devsapp/start-fc-custom-container-event-python3.9 -d fc-gpu-prj

   The scaffolded project structure:

   fc-gpu-prj
   ├── code
   │   ├── app.py        # Function code
   │   └── Dockerfile    # Image Dockerfile
   ├── README.md
   └── s.yaml            # Deployment configuration

2. Go to the project directory.

   cd fc-gpu-prj

3. Edit the configuration files. s.yaml — update the region, service name, and container image URI for your environment. The key GPU-related parameters are instanceType: fc.gpu.tesla.1 and gpuMemorySize: 8192.

   edition: 1.0.0
   name: container-demo
   access: default
   vars:
     region: cn-shenzhen
   services:
     customContainer-demo:
       component: devsapp/fc
       props:
         region: ${vars.region}
         service:
           name: tgpu_ffmpeg_service
           internetAccess: true
         function:
           name: tgpu_ffmpeg_func
           description: test gpu for ffmpeg
           handler: not-used
           timeout: 600
           caPort: 9000
           instanceType: fc.gpu.tesla.1
           gpuMemorySize: 8192
           cpu: 4
           memorySize: 16384
           diskSize: 512
           runtime: custom-container
           customContainerConfig:
             # Prerequisites:
             # 1. Create the namespace "demo" and repository "gpu-transcoding_s" in Container Registry.
             # 2. Increment the tag (e.g., v0.1 -> v0.2) when updating and redeploying.
             image: registry.cn-shanghai.aliyuncs.com/demo/gpu-transcoding_s:v0.1
           codeUri: ./code

   For the full list of YAML parameters, see YAML specifications. app.py — the function downloads a source video from OSS, transcodes it with FFmpeg (using GPU or CPU based on the TRANS-MODE header), and uploads the result back to OSS. Replace the src_url and dst_url placeholder values with your actual OSS object URLs.

   # -*- coding: utf-8 -*-
   from __future__ import print_function
   from http.server import HTTPServer, BaseHTTPRequestHandler
   import json
   import sys
   import logging
   import os
   import time
   import urllib.request
   import subprocess
   
   class Resquest(BaseHTTPRequestHandler):
       def download(self, url, path):
           print("enter download:", url)
           f = urllib.request.urlopen(url)
           with open(path, "wb") as local_file:
               local_file.write(f.read())
   
       def upload(self, url, path):
           print("enter upload:", url)
           headers = {
               'Content-Type': 'application/octet-stream',
               'Content-Length': os.stat(path).st_size,
           }
           req = urllib.request.Request(url, open(path, 'rb'), headers=headers, method='PUT')
           urllib.request.urlopen(req)
   
       def trans(self, input_path, output_path, enable_gpu):
           print("enter trans input:", input_path, " output:", output_path, " enable_gpu:", enable_gpu)
   
           cmd = ['ffmpeg', '-y', '-i', input_path, "-c:a", "copy", "-c:v", "h264", "-b:v", "5M", output_path]
           if enable_gpu:
               cmd = ["ffmpeg", "-y", "-hwaccel", "cuda", "-hwaccel_output_format", "cuda", "-i", input_path, "-c:v", "h264_nvenc", "-b:v", "5M", output_path]
   
           try:
               subprocess.run(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, check=True)
           except subprocess.CalledProcessError as exc:
               print('\nreturncode:{}'.format(exc.returncode))
               print('\ncmd:{}'.format(exc.cmd))
               print('\noutput:{}'.format(exc.output))
               print('\nstderr:{}'.format(exc.stderr))
               print('\nstdout:{}'.format(exc.stdout))
   
       def trans_wrapper(self, enable_gpu):
           src_url = "https://your.domain/input.mp4"  # Replace with your OSS object URL (read access required)
           dst_url = "https://your.domain/output.flv" # Replace with your OSS object URL (write access required)
           src_path = "/tmp/input_c.flv"
           dst_path = "/tmp/output_c.mp4"
   
           if enable_gpu:
               src_url = "https://your.domain/input.mp4"  # Replace with your OSS object URL (read access required)
               dst_url = "https://your.domain/output.flv" # Replace with your OSS object URL (write access required)
               src_path = "/tmp/input_g.flv"
               dst_path = "/tmp/output_g.mp4"
   
           local_time = time.time()
           self.download(src_url, src_path)
           download_time = time.time() - local_time
   
           local_time = time.time()
           self.trans(src_path, dst_path, enable_gpu)
           trans_time = time.time() - local_time
   
           local_time = time.time()
           self.upload(dst_url, dst_path)
           upload_time = time.time() - local_time
   
           data = {'result':'ok', 'download_time':download_time, 'trans_time':trans_time, 'upload_time':upload_time}
           self.send_response(200)
           self.send_header('Content-type', 'application/json')
           self.end_headers()
           self.wfile.write(json.dumps(data).encode())
   
       def pong(self):
           data = {"function":"trans_gpu"}
           self.send_response(200)
           self.send_header('Content-type', 'application/json')
           self.end_headers()
           self.wfile.write(json.dumps(data).encode())
   
       def dispatch(self):
           mode = self.headers.get('TRANS-MODE')
   
           if mode == "ping":
               self.pong()
           elif mode == "gpu":
               self.trans_wrapper(True)
           elif mode == "cpu":
               self.trans_wrapper(False)
           else:
               self.pong()
   
       def do_GET(self):
           self.dispatch()
   
       def do_POST(self):
           self.dispatch()
   
   if __name__ == '__main__':
       host = ('0.0.0.0', 9000)
       server = HTTPServer(host, Resquest)
       print("Starting server, listen at: %s:%s" % host)
       server.serve_forever()

   Dockerfile — builds the container image from the NVIDIA FFmpeg base image and adds a Python runtime.

   FROM registry.cn-shanghai.aliyuncs.com/serverless_devs/nvidia-ffmpeg:latest
   WORKDIR /usr/src/app
   RUN apt-get update --fix-missing
   RUN apt-get install -y python3
   RUN apt-get install -y python3-pip
   COPY . .
   ENTRYPOINT [ "python3", "-u", "/usr/src/app/app.py" ]
   EXPOSE 9000

4. Build the container image.

   s build --dockerfile ./code/Dockerfile

5. Deploy to Function Compute.

   If you run s deploy again with the same service and function names, run use local first to use local configurations.

   s deploy

6. Create a provisioned instance so the GPU function is ready to handle requests without cold start latency.

   s provision put --target 1 --qualifier LATEST

7. Verify the provisioned instance is ready.

   s provision get --qualifier LATEST

   The instance is ready when current equals 1. Example output:

   [2021-12-14 08:45:24] [INFO] [S-CLI] - Start ...
   [2021-12-14 08:45:24] [INFO] [FC] - Getting provision: tgpu_ffmpeg_service.LATEST/tgpu_ffmpeg_func
   customContainer-demo:
    serviceName:      tgpu_ffmpeg_service
    functionName:      tgpu_ffmpeg_func
    qualifier:       LATEST
    resource:        188077086902****#tgpu_ffmpeg_service#LATEST#tgpu_ffmpeg_func
    target:         1
    current:        1
    scheduledActions:    (empty array)
    targetTrackingPolicies: (empty array)
    currentError:

8. Invoke the function. Check the deployed version:

   s invoke

   Transcode with CPU:

   s invoke -e '{"method":"GET","headers":{"TRANS-MODE":"cpu"}}'

   Transcode with GPU:

   s invoke -e '{"method":"GET","headers":{"TRANS-MODE":"gpu"}}'

9. When done, release the provisioned instance to stop incurring charges.

   s provision put --target 0 --qualifier LATEST