yetangitu/Peertube
1
0
Fork 0
mirror of https://github.com/Chocobozzz/PeerTube.git synced 2025-10-04 18:29:27 +02:00
Code Issues Releases Wiki Activity

Separate HLS audio and video streams

Browse source 
Allows:
  * The HLS player to propose an "Audio only" resolution
  * The live to output an "Audio only" resolution
  * The live to ingest and output an "Audio only" stream

 This feature is under a config for VOD videos and is enabled by default for lives

 In the future we can imagine:
  * To propose multiple audio streams for a specific video
  * To ingest an audio only VOD and just output an audio only "video"
    (the player would play the audio file and PeerTube would not
    generate additional resolutions)

This commit introduce a new way to download videos:
 * Add "/download/videos/generate/:videoId" endpoint where PeerTube can
   mux an audio only and a video only file to a mp4 container
 * The download client modal introduces a new default panel where the
   user can choose resolutions it wants to download
This commit is contained in:
Chocobozzz 2024-07-23 16:38:51 +02:00 • committed by Chocobozzz
parent e77ba2dfbc
commit 816f346a60
186 changed files with 5748 additions and 2807 deletions
Download patch file Download diff file Expand all files Collapse all files

4
server/core/controllers/api/config.ts
View file

@ -347,7 +347,8 @@ function customConfig (): CustomConfig {
enabled: CONFIG.TRANSCODING.WEB_VIDEOS.ENABLED
},
hls: {
enabled: CONFIG.TRANSCODING.HLS.ENABLED
enabled: CONFIG.TRANSCODING.HLS.ENABLED,
splitAudioAndVideo: CONFIG.TRANSCODING.HLS.SPLIT_AUDIO_AND_VIDEO
}
},
live: {
@ -367,6 +368,7 @@ function customConfig (): CustomConfig {
threads: CONFIG.LIVE.TRANSCODING.THREADS,
profile: CONFIG.LIVE.TRANSCODING.PROFILE,
resolutions: {
'0p': CONFIG.LIVE.TRANSCODING.RESOLUTIONS['0p'],
'144p': CONFIG.LIVE.TRANSCODING.RESOLUTIONS['144p'],
'240p': CONFIG.LIVE.TRANSCODING.RESOLUTIONS['240p'],
'360p': CONFIG.LIVE.TRANSCODING.RESOLUTIONS['360p'],

42
server/core/controllers/api/runners/jobs-files.ts
View file

@ -1,4 +1,4 @@
import express from 'express'
import { FileStorage, RunnerJobState, VideoFileStream } from '@peertube/peertube-models'
import { logger, loggerTagsFactory } from '@server/helpers/logger.js'
import { proxifyHLS, proxifyWebVideoFile } from '@server/lib/object-storage/index.js'
import { VideoPathManager } from '@server/lib/video-path-manager.js'
@ -9,12 +9,20 @@ import {
runnerJobGetVideoStudioTaskFileValidator,
runnerJobGetVideoTranscodingFileValidator
} from '@server/middlewares/validators/runners/job-files.js'
import { RunnerJobState, FileStorage } from '@peertube/peertube-models'
import { MVideoFileStreamingPlaylistVideo, MVideoFileVideo, MVideoFullLight } from '@server/types/models/index.js'
import express from 'express'
const lTags = loggerTagsFactory('api', 'runner')
const runnerJobFilesRouter = express.Router()
runnerJobFilesRouter.post('/jobs/:jobUUID/files/videos/:videoId/max-quality/audio',
apiRateLimiter,
asyncMiddleware(jobOfRunnerGetValidatorFactory([ RunnerJobState.PROCESSING ])),
asyncMiddleware(runnerJobGetVideoTranscodingFileValidator),
asyncMiddleware(getMaxQualitySeparatedAudioFile)
)
runnerJobFilesRouter.post('/jobs/:jobUUID/files/videos/:videoId/max-quality',
apiRateLimiter,
asyncMiddleware(jobOfRunnerGetValidatorFactory([ RunnerJobState.PROCESSING ])),
@ -45,6 +53,21 @@ export {
// ---------------------------------------------------------------------------
async function getMaxQualitySeparatedAudioFile (req: express.Request, res: express.Response) {
const runnerJob = res.locals.runnerJob
const runner = runnerJob.Runner
const video = res.locals.videoAll
logger.info(
'Get max quality separated audio file of video %s of job %s for runner %s', video.uuid, runnerJob.uuid, runner.name,
lTags(runner.name, runnerJob.id, runnerJob.type)
)
const file = video.getMaxQualityFile(VideoFileStream.AUDIO) || video.getMaxQualityFile(VideoFileStream.VIDEO)
return serveVideoFile({ video, file, req, res })
}
async function getMaxQualityVideoFile (req: express.Request, res: express.Response) {
const runnerJob = res.locals.runnerJob
const runner = runnerJob.Runner
@ -55,7 +78,18 @@ async function getMaxQualityVideoFile (req: express.Request, res: express.Respon
lTags(runner.name, runnerJob.id, runnerJob.type)
)
const file = video.getMaxQualityFile()
const file = video.getMaxQualityFile(VideoFileStream.VIDEO) || video.getMaxQualityFile(VideoFileStream.AUDIO)
return serveVideoFile({ video, file, req, res })
}
async function serveVideoFile (options: {
video: MVideoFullLight
file: MVideoFileVideo | MVideoFileStreamingPlaylistVideo
req: express.Request
res: express.Response
}) {
const { video, file, req, res } = options
if (file.storage === FileStorage.OBJECT_STORAGE) {
if (file.isHLS()) {
@ -82,6 +116,8 @@ async function getMaxQualityVideoFile (req: express.Request, res: express.Respon
})
}
// ---------------------------------------------------------------------------
function getMaxQualityVideoPreview (req: express.Request, res: express.Response) {
const runnerJob = res.locals.runnerJob
const runner = runnerJob.Runner

4
server/core/controllers/api/videos/files.ts
View file

@ -2,7 +2,7 @@ import express from 'express'
import validator from 'validator'
import { logger, loggerTagsFactory } from '@server/helpers/logger.js'
import { federateVideoIfNeeded } from '@server/lib/activitypub/videos/index.js'
import { updatePlaylistAfterFileChange } from '@server/lib/hls.js'
import { updateM3U8AndShaPlaylist } from '@server/lib/hls.js'
import { removeAllWebVideoFiles, removeHLSFile, removeHLSPlaylist, removeWebVideoFile } from '@server/lib/video-file.js'
import { VideoFileModel } from '@server/models/video/video-file.js'
import { HttpStatusCode, UserRight } from '@peertube/peertube-models'
@ -89,7 +89,7 @@ async function removeHLSFileController (req: express.Request, res: express.Respo
logger.info('Deleting HLS file %d of %s.', videoFileId, video.url, lTags(video.uuid))
const playlist = await removeHLSFile(video, videoFileId)
if (playlist) await updatePlaylistAfterFileChange(video, playlist)
if (playlist) await updateM3U8AndShaPlaylist(video, playlist)
await federateVideoIfNeeded(video, false, undefined)

2
server/core/controllers/api/videos/source.ts
View file

@ -146,7 +146,7 @@ async function replaceVideoSourceResumable (req: express.Request, res: express.R
await regenerateMiniaturesIfNeeded(video, res.locals.ffprobe)
await video.VideoChannel.setAsUpdated()
await addVideoJobsAfterUpload(video, video.getMaxQualityFile())
await addVideoJobsAfterUpload(video, videoFile.withVideoOrPlaylist(video))
logger.info('Replaced video file of video %s with uuid %s.', video.name, video.uuid, lTags(video.uuid))

7
server/core/controllers/api/videos/transcoding.ts
View file

@ -1,10 +1,10 @@
import express from 'express'
import { HttpStatusCode, UserRight, VideoState, VideoTranscodingCreate } from '@peertube/peertube-models'
import { logger, loggerTagsFactory } from '@server/helpers/logger.js'
import { Hooks } from '@server/lib/plugins/hooks.js'
import { createTranscodingJobs } from '@server/lib/transcoding/create-transcoding-job.js'
import { computeResolutionsToTranscode } from '@server/lib/transcoding/transcoding-resolutions.js'
import { VideoJobInfoModel } from '@server/models/video/video-job-info.js'
import { HttpStatusCode, UserRight, VideoState, VideoTranscodingCreate } from '@peertube/peertube-models'
import express from 'express'
import { asyncMiddleware, authenticate, createTranscodingValidator, ensureUserHasRight } from '../../../middlewares/index.js'
const lTags = loggerTagsFactory('api', 'video')
@ -33,7 +33,8 @@ async function createTranscoding (req: express.Request, res: express.Response) {
await VideoJobInfoModel.abortAllTasks(video.uuid, 'pendingTranscode')
const { resolution: maxResolution, hasAudio } = await video.probeMaxQualityFile()
const maxResolution = video.getMaxResolution()
const hasAudio = video.hasAudio()
const resolutions = await Hooks.wrapObject(
computeResolutionsToTranscode({ input: maxResolution, type: 'vod', includeInput: true, strictLower: false, hasAudio }),

146
server/core/controllers/download.ts
View file

@ -1,6 +1,8 @@
import { forceNumber } from '@peertube/peertube-core-utils'
import { forceNumber, maxBy } from '@peertube/peertube-core-utils'
import { FileStorage, HttpStatusCode, VideoStreamingPlaylistType } from '@peertube/peertube-models'
import { logger } from '@server/helpers/logger.js'
import { exists } from '@server/helpers/custom-validators/misc.js'
import { logger, loggerTagsFactory } from '@server/helpers/logger.js'
import { CONFIG } from '@server/initializers/config.js'
import { VideoTorrentsSimpleFileCache } from '@server/lib/files-cache/index.js'
import {
generateHLSFilePresignedUrl,
@ -10,6 +12,7 @@ import {
} from '@server/lib/object-storage/index.js'
import { getFSUserExportFilePath } from '@server/lib/paths.js'
import { Hooks } from '@server/lib/plugins/hooks.js'
import { muxToMergeVideoFiles } from '@server/lib/video-file.js'
import { VideoPathManager } from '@server/lib/video-path-manager.js'
import {
MStreamingPlaylist,
@ -22,45 +25,67 @@ import {
import { MVideoSource } from '@server/types/models/video/video-source.js'
import cors from 'cors'
import express from 'express'
import { STATIC_DOWNLOAD_PATHS } from '../initializers/constants.js'
import { DOWNLOAD_PATHS } from '../initializers/constants.js'
import {
asyncMiddleware, optionalAuthenticate,
asyncMiddleware, buildRateLimiter, optionalAuthenticate,
originalVideoFileDownloadValidator,
userExportDownloadValidator,
videosDownloadValidator
videosDownloadValidator,
videosGenerateDownloadValidator
} from '../middlewares/index.js'
const lTags = loggerTagsFactory('download')
const downloadRouter = express.Router()
downloadRouter.use(cors())
downloadRouter.use(
STATIC_DOWNLOAD_PATHS.TORRENTS + ':filename',
DOWNLOAD_PATHS.TORRENTS + ':filename',
asyncMiddleware(downloadTorrent)
)
// ---------------------------------------------------------------------------
downloadRouter.use(
STATIC_DOWNLOAD_PATHS.VIDEOS + ':id-:resolution([0-9]+).:extension',
DOWNLOAD_PATHS.WEB_VIDEOS + ':id-:resolution([0-9]+).:extension',
optionalAuthenticate,
asyncMiddleware(videosDownloadValidator),
asyncMiddleware(downloadWebVideoFile)
)
downloadRouter.use(
STATIC_DOWNLOAD_PATHS.HLS_VIDEOS + ':id-:resolution([0-9]+)-fragmented.:extension',
DOWNLOAD_PATHS.HLS_VIDEOS + ':id-:resolution([0-9]+)-fragmented.:extension',
optionalAuthenticate,
asyncMiddleware(videosDownloadValidator),
asyncMiddleware(downloadHLSVideoFile)
)
const downloadGenerateRateLimiter = buildRateLimiter({
windowMs: CONFIG.RATES_LIMIT.DOWNLOAD_GENERATE_VIDEO.WINDOW_MS,
max: CONFIG.RATES_LIMIT.DOWNLOAD_GENERATE_VIDEO.MAX,
skipFailedRequests: true
})
downloadRouter.use(
STATIC_DOWNLOAD_PATHS.USER_EXPORTS + ':filename',
DOWNLOAD_PATHS.GENERATE_VIDEO + ':id',
downloadGenerateRateLimiter,
optionalAuthenticate,
asyncMiddleware(videosDownloadValidator),
videosGenerateDownloadValidator,
asyncMiddleware(downloadGeneratedVideoFile)
)
// ---------------------------------------------------------------------------
downloadRouter.use(
DOWNLOAD_PATHS.USER_EXPORTS + ':filename',
asyncMiddleware(userExportDownloadValidator), // Include JWT token authentication
asyncMiddleware(downloadUserExport)
)
downloadRouter.use(
STATIC_DOWNLOAD_PATHS.ORIGINAL_VIDEO_FILE + ':filename',
DOWNLOAD_PATHS.ORIGINAL_VIDEO_FILE + ':filename',
optionalAuthenticate,
asyncMiddleware(originalVideoFileDownloadValidator),
asyncMiddleware(downloadOriginalFile)
@ -101,10 +126,12 @@ async function downloadTorrent (req: express.Request, res: express.Response) {
return res.download(result.path, result.downloadName)
}
// ---------------------------------------------------------------------------
async function downloadWebVideoFile (req: express.Request, res: express.Response) {
const video = res.locals.videoAll
const videoFile = getVideoFile(req, video.VideoFiles)
const videoFile = getVideoFileFromReq(req, video.VideoFiles)
if (!videoFile) {
return res.fail({
status: HttpStatusCode.NOT_FOUND_404,
@ -127,9 +154,7 @@ async function downloadWebVideoFile (req: express.Request, res: express.Response
if (!checkAllowResult(res, allowParameters, allowedResult)) return
// Express uses basename on filename parameter
const videoName = video.name.replace(/[/\\]/g, '_')
const downloadFilename = `${videoName}-${videoFile.resolution}p${videoFile.extname}`
const downloadFilename = buildDownloadFilename({ video, resolution: videoFile.resolution, extname: videoFile.extname })
if (videoFile.storage === FileStorage.OBJECT_STORAGE) {
return redirectVideoDownloadToObjectStorage({ res, video, file: videoFile, downloadFilename })
@ -145,7 +170,7 @@ async function downloadHLSVideoFile (req: express.Request, res: express.Response
const streamingPlaylist = getHLSPlaylist(video)
if (!streamingPlaylist) return res.sendStatus(HttpStatusCode.NOT_FOUND_404)
const videoFile = getVideoFile(req, streamingPlaylist.VideoFiles)
const videoFile = getVideoFileFromReq(req, streamingPlaylist.VideoFiles)
if (!videoFile) {
return res.fail({
status: HttpStatusCode.NOT_FOUND_404,
@ -169,8 +194,7 @@ async function downloadHLSVideoFile (req: express.Request, res: express.Response
if (!checkAllowResult(res, allowParameters, allowedResult)) return
const videoName = video.name.replace(/\//g, '_')
const downloadFilename = `${videoName}-${videoFile.resolution}p-${streamingPlaylist.getStringType()}${videoFile.extname}`
const downloadFilename = buildDownloadFilename({ video, streamingPlaylist, resolution: videoFile.resolution, extname: videoFile.extname })
if (videoFile.storage === FileStorage.OBJECT_STORAGE) {
return redirectVideoDownloadToObjectStorage({ res, video, streamingPlaylist, file: videoFile, downloadFilename })
@ -181,6 +205,53 @@ async function downloadHLSVideoFile (req: express.Request, res: express.Response
})
}
// ---------------------------------------------------------------------------
async function downloadGeneratedVideoFile (req: express.Request, res: express.Response) {
const video = res.locals.videoAll
const filesToSelect = req.query.videoFileIds
const videoFiles = video.getAllFiles()
.filter(f => filesToSelect.includes(f.id))
if (videoFiles.length === 0) {
return res.fail({
status: HttpStatusCode.NOT_FOUND_404,
message: `No files found (${filesToSelect.join(', ')}) to download video ${video.url}`
})
}
if (videoFiles.filter(f => f.hasVideo()).length > 1 || videoFiles.filter(f => f.hasAudio()).length > 1) {
return res.fail({
status: HttpStatusCode.BAD_REQUEST_400,
// In theory we could, but ffmpeg-fluent doesn't support multiple input streams so prefer to reject this specific use case
message: `Cannot generate a container with multiple video/audio files. PeerTube supports a maximum of 1 audio and 1 video file`
})
}
const allowParameters = {
req,
res,
video,
videoFiles
}
const allowedResult = await Hooks.wrapFun(
isGeneratedVideoDownloadAllowed,
allowParameters,
'filter:api.download.generated-video.allowed.result'
)
if (!checkAllowResult(res, allowParameters, allowedResult)) return
const downloadFilename = buildDownloadFilename({ video, extname: maxBy(videoFiles, 'resolution').extname })
res.setHeader('Content-disposition', `attachment; filename="${encodeURI(downloadFilename)}`)
await muxToMergeVideoFiles({ video, videoFiles, output: res })
}
// ---------------------------------------------------------------------------
function downloadUserExport (req: express.Request, res: express.Response) {
const userExport = res.locals.userExport
@ -209,7 +280,7 @@ function downloadOriginalFile (req: express.Request, res: express.Response) {
// ---------------------------------------------------------------------------
function getVideoFile (req: express.Request, files: MVideoFile[]) {
function getVideoFileFromReq (req: express.Request, files: MVideoFile[]) {
const resolution = forceNumber(req.params.resolution)
return files.find(f => f.resolution === resolution)
}
@ -240,9 +311,18 @@ function isVideoDownloadAllowed (_object: {
return { allowed: true }
}
function isGeneratedVideoDownloadAllowed (_object: {
video: MVideo
videoFiles: MVideoFile[]
}): AllowedResult {
return { allowed: true }
}
// ---------------------------------------------------------------------------
function checkAllowResult (res: express.Response, allowParameters: any, result?: AllowedResult) {
if (!result || result.allowed !== true) {
logger.info('Download is not allowed.', { result, allowParameters })
logger.info('Download is not allowed.', { result, allowParameters, ...lTags() })
res.fail({
status: HttpStatusCode.FORBIDDEN_403,
@ -267,7 +347,7 @@ async function redirectVideoDownloadToObjectStorage (options: {
? await generateHLSFilePresignedUrl({ streamingPlaylist, file, downloadFilename })
: await generateWebVideoPresignedUrl({ file, downloadFilename })
logger.debug('Generating pre-signed URL %s for video %s', url, video.uuid)
logger.debug('Generating pre-signed URL %s for video %s', url, video.uuid, lTags())
return res.redirect(url)
}
@ -281,7 +361,7 @@ async function redirectUserExportToObjectStorage (options: {
const url = await generateUserExportPresignedUrl({ userExport, downloadFilename })
logger.debug('Generating pre-signed URL %s for user export %s', url, userExport.filename)
logger.debug('Generating pre-signed URL %s for user export %s', url, userExport.filename, lTags())
return res.redirect(url)
}
@ -295,7 +375,29 @@ async function redirectOriginalFileToObjectStorage (options: {
const url = await generateOriginalFilePresignedUrl({ videoSource, downloadFilename })
logger.debug('Generating pre-signed URL %s for original video file %s', url, videoSource.keptOriginalFilename)
logger.debug('Generating pre-signed URL %s for original video file %s', url, videoSource.keptOriginalFilename, lTags())
return res.redirect(url)
}
function buildDownloadFilename (options: {
video: MVideo
streamingPlaylist?: MStreamingPlaylist
resolution?: number
extname: string
}) {
const { video, resolution, extname, streamingPlaylist } = options
// Express uses basename on filename parameter
const videoName = video.name.replace(/[/\\]/g, '_')
const suffixStr = streamingPlaylist
? `-${streamingPlaylist.getStringType()}`
: ''
const resolutionStr = exists(resolution)
? `-${resolution}p`
: ''
return videoName + resolutionStr + suffixStr + extname
}