488 lines
16 KiB
Go
488 lines
16 KiB
Go
package laosiji
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"crypto/md5"
|
|
"encoding/hex"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"net/http"
|
|
"net/url"
|
|
"path"
|
|
"strings"
|
|
"time"
|
|
|
|
"91porn-server/common/hevcpull"
|
|
"91porn-server/common/log"
|
|
)
|
|
|
|
const (
|
|
videoTranscodingVersion = "2.0"
|
|
transcodeNoNeedStatus = 4
|
|
transcodeSuccessStatus = 5
|
|
transcodeFailedStatus = -1
|
|
|
|
sourceM3u8CheckMaxBytes = 8 << 20
|
|
)
|
|
|
|
var (
|
|
errTranscodeTaskNotFound = errors.New("laosiji transcode task not found")
|
|
// ErrTranscodeQueueFull 表示云端 H.265 待处理队列已经达到限制。
|
|
ErrTranscodeQueueFull = errors.New("laosiji transcode queue full")
|
|
sourceM3u8HTTPClient = &http.Client{Timeout: 15 * time.Second}
|
|
uploadHTTPClient = &http.Client{Timeout: 30 * time.Second}
|
|
)
|
|
|
|
// SystemDomainsResp 是老司机 system/domains 接口返回的资源域名和上传配置。
|
|
type SystemDomainsResp struct {
|
|
ImgFreeCDN string `json:"img_free_cdn"`
|
|
MovieFreeCDN string `json:"movie_free_cdn"`
|
|
MovieSourceCDN string `json:"movie_source_cdn"`
|
|
UploadURL string `json:"upload_url"`
|
|
MediaDir string `json:"media_dir"`
|
|
UploadKey string `json:"upload_key"`
|
|
UserID string `json:"user_id"`
|
|
}
|
|
|
|
type transcodeAPIResp struct {
|
|
Status string `json:"status"`
|
|
Data json.RawMessage `json:"data"`
|
|
Time string `json:"time"`
|
|
Error string `json:"error"`
|
|
ErrorCode int `json:"errorCode"`
|
|
}
|
|
|
|
type transcodeTask struct {
|
|
ID string `json:"id"`
|
|
FileID string `json:"file_id"`
|
|
FileURL string `json:"file_url"`
|
|
Status int `json:"status"`
|
|
Duration int `json:"duration"`
|
|
Height int `json:"height"`
|
|
Width int `json:"width"`
|
|
TranscodeError string `json:"transcode_error"`
|
|
TranscodeFile string `json:"transcode_file"`
|
|
}
|
|
|
|
// TranscodeQueueInfo 是云端转码队列概览。
|
|
type TranscodeQueueInfo struct {
|
|
Waiting int `json:"waiting"`
|
|
Done int `json:"done"`
|
|
Error int `json:"error"`
|
|
}
|
|
|
|
// TranscodeResult 是本地异步任务使用的统一转码结果。
|
|
type TranscodeResult struct {
|
|
Status int
|
|
Done bool
|
|
NoNeed bool
|
|
Failed bool
|
|
HevcURL string
|
|
FileURL string
|
|
FileID string
|
|
ErrorMsg string
|
|
}
|
|
|
|
func getSystemDomainsURL() string {
|
|
return strings.TrimRight(APIUrl, "/") + "/lsjapi/system/domains"
|
|
}
|
|
|
|
// SystemDomains 获取老司机临时上传、转码配置。
|
|
func SystemDomains(ctx context.Context) (resp SystemDomainsResp, err error) {
|
|
if err = ensureConfigured(); err != nil {
|
|
return resp, err
|
|
}
|
|
if err = moviePost(ctx, getSystemDomainsURL(), map[string]interface{}{}, &resp); err != nil {
|
|
return resp, err
|
|
}
|
|
missing := make([]string, 0, 3)
|
|
if strings.TrimSpace(resp.UploadURL) == "" {
|
|
missing = append(missing, "upload_url")
|
|
}
|
|
if strings.TrimSpace(resp.UploadKey) == "" {
|
|
missing = append(missing, "upload_key")
|
|
}
|
|
if strings.TrimSpace(resp.MovieSourceCDN) == "" {
|
|
missing = append(missing, "movie_source_cdn")
|
|
}
|
|
if len(missing) > 0 {
|
|
return resp, fmt.Errorf("laosiji system/domains missing: %s", strings.Join(missing, ","))
|
|
}
|
|
return resp, nil
|
|
}
|
|
|
|
// SubmitH264ToH265ByFileURL 使用完整 file_url 异步提交转码任务。
|
|
func SubmitH264ToH265ByFileURL(ctx context.Context, fileURL string, domains SystemDomainsResp, maxRunning int) (TranscodeResult, error) {
|
|
fileURL = strings.TrimSpace(fileURL)
|
|
if fileURL == "" {
|
|
return TranscodeResult{}, errors.New("empty file url")
|
|
}
|
|
return submitByTask(ctx, md5Hex(fileURL), fileURL, domains, maxRunning)
|
|
}
|
|
|
|
// SubmitH264ToH265Task decouples the stable cloud task ID from the temporary
|
|
// signed fetch URL. This keeps polling stable across App domain or signing-key
|
|
// changes while a task is pending.
|
|
func SubmitH264ToH265Task(ctx context.Context, fileID, fileURL string, domains SystemDomainsResp, maxRunning int) (TranscodeResult, error) {
|
|
fileID = strings.TrimSpace(fileID)
|
|
fileURL = strings.TrimSpace(fileURL)
|
|
if fileID == "" {
|
|
return TranscodeResult{}, errors.New("empty file id")
|
|
}
|
|
if fileURL == "" {
|
|
return TranscodeResult{}, errors.New("empty file url")
|
|
}
|
|
return submitByTask(ctx, fileID, fileURL, domains, maxRunning)
|
|
}
|
|
|
|
func submitByTask(ctx context.Context, fileID, fileURL string, domains SystemDomainsResp, maxRunning int) (TranscodeResult, error) {
|
|
task, err := queryVideoTranscoding(ctx, domains, fileID)
|
|
if err == nil {
|
|
return transcodeTaskToResult(domains, task, fileURL, fileID), nil
|
|
}
|
|
if !errors.Is(err, errTranscodeTaskNotFound) {
|
|
return TranscodeResult{}, err
|
|
}
|
|
if err = checkSourceM3u8(ctx, fileURL); err != nil {
|
|
return TranscodeResult{}, err
|
|
}
|
|
task, err = createVideoTranscoding(ctx, domains, fileID, fileURL, maxRunning)
|
|
if err != nil {
|
|
return TranscodeResult{}, err
|
|
}
|
|
return transcodeTaskToResult(domains, task, fileURL, fileID), nil
|
|
}
|
|
|
|
func checkSourceM3u8(ctx context.Context, fileURL string) error {
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, fileURL, nil)
|
|
if err != nil {
|
|
return fmt.Errorf("build source m3u8 request: %s", hevcpull.RedactText(err.Error()))
|
|
}
|
|
resp, err := sourceM3u8HTTPClient.Do(req)
|
|
if err != nil {
|
|
return fmt.Errorf("source m3u8 request failed: %s", hevcpull.RedactText(err.Error()))
|
|
}
|
|
defer resp.Body.Close()
|
|
if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
|
|
return fmt.Errorf("source m3u8 http status:%d url:%s", resp.StatusCode, hevcpull.RedactURL(fileURL))
|
|
}
|
|
body, err := io.ReadAll(io.LimitReader(resp.Body, sourceM3u8CheckMaxBytes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !looksLikeM3u8(body) {
|
|
return fmt.Errorf("source m3u8 invalid content url:%s", hevcpull.RedactURL(fileURL))
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func looksLikeM3u8(body []byte) bool {
|
|
body = bytes.TrimPrefix(body, []byte{0xEF, 0xBB, 0xBF})
|
|
body = bytes.TrimLeft(body, " \t\r\n")
|
|
return bytes.HasPrefix(body, []byte("#EXTM3U"))
|
|
}
|
|
|
|
// QueryH264ToH265 查询老司机源视频对应的 H.265 云转码结果。
|
|
func QueryH264ToH265(ctx context.Context, h264URL string) (TranscodeResult, bool, error) {
|
|
domains, err := SystemDomains(ctx)
|
|
if err != nil {
|
|
return TranscodeResult{}, false, err
|
|
}
|
|
return QueryH264ToH265WithDomains(ctx, h264URL, domains)
|
|
}
|
|
|
|
// QueryH264ToH265WithDomains 使用已经获取的域名配置查询转码结果。
|
|
func QueryH264ToH265WithDomains(ctx context.Context, h264URL string, domains SystemDomainsResp) (TranscodeResult, bool, error) {
|
|
h264URL = strings.TrimSpace(h264URL)
|
|
if h264URL == "" {
|
|
return TranscodeResult{}, false, errors.New("empty h264 m3u8 url")
|
|
}
|
|
return queryByFileURL(ctx, transcodeSourceURL(h264URL, domains.MovieSourceCDN), domains)
|
|
}
|
|
|
|
// QueryH264ToH265ByFileURL 与 SubmitH264ToH265ByFileURL 使用相同的完整 file_url 查询结果。
|
|
func QueryH264ToH265ByFileURL(ctx context.Context, fileURL string, domains SystemDomainsResp) (TranscodeResult, bool, error) {
|
|
fileURL = strings.TrimSpace(fileURL)
|
|
if fileURL == "" {
|
|
return TranscodeResult{}, false, errors.New("empty file url")
|
|
}
|
|
return queryByTask(ctx, md5Hex(fileURL), fileURL, domains)
|
|
}
|
|
|
|
func queryByFileURL(ctx context.Context, fileURL string, domains SystemDomainsResp) (TranscodeResult, bool, error) {
|
|
return queryByTask(ctx, md5Hex(fileURL), fileURL, domains)
|
|
}
|
|
|
|
// QueryH264ToH265Task queries by the stable task ID used during submission.
|
|
// fileURL is diagnostic metadata only and is not sent to the cloud query API.
|
|
func QueryH264ToH265Task(ctx context.Context, fileID, fileURL string, domains SystemDomainsResp) (TranscodeResult, bool, error) {
|
|
fileID = strings.TrimSpace(fileID)
|
|
fileURL = strings.TrimSpace(fileURL)
|
|
if fileID == "" {
|
|
return TranscodeResult{}, false, errors.New("empty file id")
|
|
}
|
|
return queryByTask(ctx, fileID, fileURL, domains)
|
|
}
|
|
|
|
func queryByTask(ctx context.Context, fileID, fileURL string, domains SystemDomainsResp) (TranscodeResult, bool, error) {
|
|
task, err := queryVideoTranscoding(ctx, domains, fileID)
|
|
if err != nil {
|
|
if errors.Is(err, errTranscodeTaskNotFound) {
|
|
return TranscodeResult{}, false, nil
|
|
}
|
|
return TranscodeResult{}, false, err
|
|
}
|
|
return transcodeTaskToResult(domains, task, fileURL, fileID), true, nil
|
|
}
|
|
|
|
func transcodeSourceURL(rawURL, movieSourceCDN string) string {
|
|
rawURL = strings.TrimSpace(rawURL)
|
|
movieSourceCDN = strings.TrimSpace(movieSourceCDN)
|
|
if rawURL == "" || movieSourceCDN == "" {
|
|
return rawURL
|
|
}
|
|
parsed, err := url.Parse(rawURL)
|
|
if err == nil && parsed.Scheme != "" {
|
|
name := path.Base(parsed.Path)
|
|
if name != "" && name != "." && strings.Contains(name, ".m3u8") {
|
|
return joinURLPath(movieSourceCDN, name)
|
|
}
|
|
return rawURL
|
|
}
|
|
rawURL = strings.TrimPrefix(rawURL, "/")
|
|
rawURL = strings.TrimPrefix(rawURL, "laosiji/")
|
|
if idx := strings.Index(rawURL, "m3m/"); idx >= 0 {
|
|
rawURL = rawURL[idx+len("m3m/"):]
|
|
}
|
|
return joinURLPath(movieSourceCDN, rawURL)
|
|
}
|
|
|
|
// TranscodeSourceURL 把本地资源 path 或播放 URL 转换成云转码使用的源站 URL。
|
|
func TranscodeSourceURL(rawURL, movieSourceCDN string) string {
|
|
return transcodeSourceURL(rawURL, movieSourceCDN)
|
|
}
|
|
|
|
func createVideoTranscoding(ctx context.Context, domains SystemDomainsResp, fileID, fileURL string, maxRunning int) (transcodeTask, error) {
|
|
if q, err := getVideoTranscodingQueue(ctx, domains); err != nil {
|
|
log.Warn("getVideoTranscodingQueue failed", log.E(err))
|
|
} else if maxRunning > 0 && q.Waiting >= maxRunning {
|
|
return transcodeTask{}, fmt.Errorf("%w waiting:%d limit:%d", ErrTranscodeQueueFull, q.Waiting, maxRunning)
|
|
}
|
|
params := map[string]string{
|
|
"v": videoTranscodingVersion,
|
|
"key": domains.UploadKey,
|
|
"file_id": fileID,
|
|
"file_url": fileURL,
|
|
"ext_data": `{"project":"91porn","source":"laosiji","type":"full"}`,
|
|
}
|
|
if NoticeURL != "" {
|
|
params["notice_url"] = NoticeURL
|
|
}
|
|
endpoint := joinURLPath(domains.UploadURL, "upload/videoTranscoding")
|
|
return uploadAPIGet(ctx, endpoint, params)
|
|
}
|
|
|
|
func getVideoTranscodingQueue(ctx context.Context, domains SystemDomainsResp) (TranscodeQueueInfo, error) {
|
|
endpoint := joinURLPath(domains.UploadURL, "upload/getVideoTranscodingQueueInfo")
|
|
data, err := uploadAPICall(ctx, endpoint, map[string]string{
|
|
"v": videoTranscodingVersion,
|
|
"key": domains.UploadKey,
|
|
})
|
|
if err != nil {
|
|
return TranscodeQueueInfo{}, err
|
|
}
|
|
var queue TranscodeQueueInfo
|
|
if len(data) > 0 {
|
|
if err = json.Unmarshal(data, &queue); err != nil {
|
|
return TranscodeQueueInfo{}, err
|
|
}
|
|
}
|
|
return queue, nil
|
|
}
|
|
|
|
func queryVideoTranscoding(ctx context.Context, domains SystemDomainsResp, fileID string) (transcodeTask, error) {
|
|
endpoint := joinURLPath(domains.UploadURL, "upload/queryVideoTranscoding")
|
|
return uploadAPIGet(ctx, endpoint, map[string]string{
|
|
"v": videoTranscodingVersion,
|
|
"key": domains.UploadKey,
|
|
"file_id": fileID,
|
|
})
|
|
}
|
|
|
|
func transcodeTaskToResult(domains SystemDomainsResp, task transcodeTask, fileURL, fileID string) TranscodeResult {
|
|
result := TranscodeResult{Status: task.Status, FileURL: fileURL, FileID: fileID}
|
|
switch {
|
|
case task.Status == transcodeNoNeedStatus:
|
|
result.Done = true
|
|
result.NoNeed = true
|
|
result.HevcURL = task.FileURL
|
|
case task.Status == transcodeSuccessStatus:
|
|
if transcodeFile := strings.TrimSpace(task.TranscodeFile); transcodeFile != "" {
|
|
result.Done = true
|
|
result.HevcURL = joinURLPath(domains.MovieSourceCDN, transcodeFile)
|
|
} else {
|
|
result.Failed = true
|
|
result.ErrorMsg = "laosiji transcode succeeded without transcode_file"
|
|
}
|
|
case task.Status <= transcodeFailedStatus:
|
|
result.Failed = true
|
|
result.ErrorMsg = truncateToolText(task.TranscodeError, domains.UploadKey)
|
|
if result.ErrorMsg == "" {
|
|
result.ErrorMsg = fmt.Sprintf("laosiji transcode failed status:%d", task.Status)
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
func uploadAPIGet(ctx context.Context, endpoint string, params map[string]string) (transcodeTask, error) {
|
|
data, err := uploadAPICall(ctx, endpoint, params)
|
|
if err != nil {
|
|
return transcodeTask{}, err
|
|
}
|
|
var task transcodeTask
|
|
if len(data) > 0 {
|
|
if err = json.Unmarshal(data, &task); err != nil {
|
|
return transcodeTask{}, err
|
|
}
|
|
}
|
|
return task, nil
|
|
}
|
|
|
|
func uploadAPICall(ctx context.Context, endpoint string, params map[string]string) (json.RawMessage, error) {
|
|
parsed, err := url.Parse(endpoint)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
query := parsed.Query()
|
|
for key, value := range params {
|
|
query.Set(key, value)
|
|
}
|
|
parsed.RawQuery = query.Encode()
|
|
|
|
req, err := http.NewRequestWithContext(ctx, http.MethodGet, parsed.String(), nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
resp, err := uploadHTTPClient.Do(req)
|
|
if err != nil {
|
|
return nil, fmt.Errorf("upload api request failed: %s", truncateToolText(err.Error(), params["key"]))
|
|
}
|
|
defer resp.Body.Close()
|
|
body, err := io.ReadAll(resp.Body)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
safeBody := truncateToolBody(body, params["key"])
|
|
if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
|
|
return nil, fmt.Errorf("upload api http status:%d body:%s", resp.StatusCode, safeBody)
|
|
}
|
|
var apiResp transcodeAPIResp
|
|
if err = json.Unmarshal(body, &apiResp); err != nil {
|
|
return nil, err
|
|
}
|
|
if apiResp.Status != "y" {
|
|
errMsg := truncateToolText(apiResp.Error, params["key"])
|
|
if strings.Contains(errMsg, "最多允许待处理") || strings.Contains(errMsg, "排队处理") {
|
|
return nil, fmt.Errorf("%w errorCode:%d error:%s", ErrTranscodeQueueFull, apiResp.ErrorCode, errMsg)
|
|
}
|
|
if apiResp.ErrorCode == 2000 {
|
|
return nil, fmt.Errorf("%w errorCode:%d error:%s", errTranscodeTaskNotFound, apiResp.ErrorCode, errMsg)
|
|
}
|
|
return nil, fmt.Errorf("upload api errorCode:%d error:%s", apiResp.ErrorCode, errMsg)
|
|
}
|
|
return apiResp.Data, nil
|
|
}
|
|
|
|
func md5Hex(value string) string {
|
|
sum := md5.Sum([]byte(value))
|
|
return hex.EncodeToString(sum[:])
|
|
}
|
|
|
|
// TranscodeFileID 返回源视频 URL 对应的云端幂等键。
|
|
func TranscodeFileID(fileURL string) string {
|
|
fileURL = strings.TrimSpace(fileURL)
|
|
if fileURL == "" {
|
|
return ""
|
|
}
|
|
return md5Hex(fileURL)
|
|
}
|
|
|
|
func joinURLPath(host, uri string) string {
|
|
host = strings.TrimRight(strings.TrimSpace(host), "/")
|
|
uri = strings.TrimLeft(strings.TrimSpace(uri), "/")
|
|
if host == "" {
|
|
return uri
|
|
}
|
|
if uri == "" {
|
|
return host
|
|
}
|
|
return host + "/" + uri
|
|
}
|
|
|
|
// MovieM3u8SourcePath 把完整 URL 或相对路径规范成本地保存的老司机资源 path。
|
|
func MovieM3u8SourcePath(raw string) string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return ""
|
|
}
|
|
return joinURLPath("laosiji", movieM3u8RelativePath(raw))
|
|
}
|
|
|
|
// MovieM3u8OriginURL 把本地老司机资源 path 还原成源站完整 URL。
|
|
func MovieM3u8OriginURL(raw string) string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return ""
|
|
}
|
|
if parsed, err := url.Parse(raw); err == nil && parsed.IsAbs() {
|
|
return raw
|
|
}
|
|
return joinURLPath(APIUrl, movieM3u8RelativePath(raw))
|
|
}
|
|
|
|
func movieM3u8RelativePath(raw string) string {
|
|
raw = strings.TrimSpace(raw)
|
|
if raw == "" {
|
|
return ""
|
|
}
|
|
if parsed, err := url.Parse(raw); err == nil {
|
|
if parsed.IsAbs() {
|
|
raw = parsed.Path
|
|
} else if parsed.Path != "" {
|
|
raw = parsed.Path
|
|
}
|
|
}
|
|
raw = strings.TrimPrefix(raw, "/")
|
|
raw = strings.TrimPrefix(raw, "laosiji/")
|
|
if idx := strings.Index(raw, "m3m/"); idx >= 0 {
|
|
return raw[idx:]
|
|
}
|
|
if strings.Contains(raw, "/") {
|
|
return raw
|
|
}
|
|
return joinURLPath("m3m", raw)
|
|
}
|
|
|
|
func truncateToolBody(body []byte, secrets ...string) string {
|
|
return truncateToolText(string(body), secrets...)
|
|
}
|
|
|
|
func truncateToolText(text string, secrets ...string) string {
|
|
const limit = 300
|
|
text = hevcpull.RedactText(strings.TrimSpace(text))
|
|
secrets = append(secrets, APIKey, Appid)
|
|
for _, secret := range secrets {
|
|
if secret = strings.TrimSpace(secret); secret != "" {
|
|
text = strings.ReplaceAll(text, secret, "[REDACTED]")
|
|
text = strings.ReplaceAll(text, url.QueryEscape(secret), "[REDACTED]")
|
|
}
|
|
}
|
|
if len(text) <= limit {
|
|
return text
|
|
}
|
|
return text[:limit] + "..."
|
|
}
|