microsoft/playwright
1
1
Fork 0
mirror of https://github.com/microsoft/playwright.git synced 2024-12-14 21:53:35 +03:00
Code Issues Projects Releases Wiki Activity

chore(screencast): respect i/o backpressure when writing into ffmpeg (#4164)

Browse Source
This commit is contained in:
Pavel Feldman 2020-10-16 10:04:14 -07:00 committed by GitHub
parent 26442c563c
commit bbdba42d30
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 30 additions and 44 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

74
src/server/chromium/videoRecorder.ts
View File

@ -16,7 +16,7 @@
import { ChildProcess } from 'child_process';
import { ffmpegExecutable } from '../../utils/binaryPaths';
import { assert } from '../../utils/utils';
import { assert, monotonicTime } from '../../utils/utils';
import { launchProcess } from '../processLauncher';
import { Progress, ProgressController } from '../progress';
import * as types from '../types';
@ -26,11 +26,13 @@ const fps = 25;
export class VideoRecorder {
private _process: ChildProcess | null = null;
private _gracefullyClose: (() => Promise<void>) | null = null;
private _lastWritePromise: Promise<void> | undefined;
private _lastWritePromise: Promise<void> = Promise.resolve();
private _lastFrameTimestamp: number = 0;
private _lastFrameBuffer: Buffer | null = null;
private _lastWriteTimestamp: number = 0;
private readonly _progress: Progress;
private _frameQueue: Buffer[] = [];
private _isStopped = false;
static async launch(options: types.PageScreencastOptions): Promise<VideoRecorder> {
if (!options.outputFile.endsWith('.webm'))
@ -50,7 +52,6 @@ export class VideoRecorder {
}
private async _launch(options: types.PageScreencastOptions) {
assert(!this._isRunning());
const w = options.width;
const h = options.height;
const args = `-loglevel error -f image2pipe -c:v mjpeg -i - -y -an -r ${fps} -c:v vp8 -qmin 0 -qmax 50 -crf 8 -b:v 1M -vf pad=${w}:${h}:0:0:gray,crop=${w}:${h}:0:0`.split(' ');
@ -84,58 +85,43 @@ export class VideoRecorder {
this._gracefullyClose = gracefullyClose;
}
async writeFrame(frame: Buffer, timestamp: number) {
writeFrame(frame: Buffer, timestamp: number) {
assert(this._process);
if (!this._isRunning())
if (this._isStopped)
return;
this._progress.log(`writing frame ` + timestamp);
if (this._lastFrameBuffer)
this._lastWritePromise = this._flushLastFrame(timestamp - this._lastFrameTimestamp).catch(e => this._progress.log('Error while writing frame: ' + e));
if (this._lastFrameBuffer) {
const durationSec = timestamp - this._lastFrameTimestamp;
const repeatCount = Math.max(1, Math.round(fps * durationSec));
for (let i = 0; i < repeatCount; ++i)
this._frameQueue.push(this._lastFrameBuffer);
this._lastWritePromise = this._lastWritePromise.then(() => this._sendFrames());
}
this._lastFrameBuffer = frame;
this._lastFrameTimestamp = timestamp;
this._lastWriteTimestamp = Date.now();
this._lastWriteTimestamp = monotonicTime();
}
private async _flushLastFrame(durationSec: number): Promise<void> {
assert(this._process);
const frame = this._lastFrameBuffer;
if (!frame)
return;
const previousWrites = this._lastWritePromise;
let finishedWriting: () => void;
const writePromise = new Promise<void>(fulfill => finishedWriting = fulfill);
const repeatCount = Math.max(1, Math.round(fps * durationSec));
this._progress.log(`flushing ${repeatCount} frame(s)`);
await previousWrites;
for (let i = 0; i < repeatCount; i++) {
const callFinish = i === (repeatCount - 1);
this._process.stdin.write(frame, (error: Error | null | undefined) => {
if (error)
this._progress.log(`ffmpeg failed to write: ${error}`);
if (callFinish)
finishedWriting();
});
}
return writePromise;
private async _sendFrames() {
while (this._frameQueue.length)
await this._sendFrame(this._frameQueue.shift()!);
}
private async _sendFrame(frame: Buffer) {
return new Promise(f => this._process!.stdin.write(frame, f)).then(error => {
if (error)
this._progress.log(`ffmpeg failed to write: ${error}`);
});
}
async stop() {
if (!this._gracefullyClose)
if (this._isStopped)
return;
if (this._lastWriteTimestamp) {
const durationSec = (Date.now() - this._lastWriteTimestamp) / 1000;
if (!this._lastWritePromise || durationSec > 1 / fps)
this._flushLastFrame(durationSec).catch(e => this._progress.log('Error while writing frame: ' + e));
}
const close = this._gracefullyClose;
this._gracefullyClose = null;
this.writeFrame(Buffer.from([]), this._lastFrameTimestamp + (monotonicTime() - this._lastWriteTimestamp) / 1000);
this._isStopped = true;
await this._lastWritePromise;
await close();
}
private _isRunning(): boolean {
return !!this._gracefullyClose;
await this._gracefullyClose!();
}
}