mirror of
https://github.com/arcodange-org/mediabunny.git
synced 2026-09-28 03:13:51 +02:00
355 lines
11 KiB
TypeScript
355 lines
11 KiB
TypeScript
import { expect, test } from 'vitest';
|
|
import { Input, InputDisposedError } from '../../src/input.js';
|
|
import { BufferSource, FilePathSource } from '../../src/source.js';
|
|
import path from 'node:path';
|
|
import fs from 'node:fs';
|
|
import { ALL_FORMATS } from '../../src/input-format.js';
|
|
import { PacketCursor, PacketReader } from '../../src/cursors.js';
|
|
import { promiseAllEnsureOrder } from '../../src/misc.js';
|
|
|
|
const __dirname = new URL('.', import.meta.url).pathname;
|
|
|
|
test('Packet reader', async () => {
|
|
using input = new Input({
|
|
source: new FilePathSource(path.join(__dirname, '../public/trim-buck-bunny.mov')),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
|
|
const packet1 = (await reader.readFirst())!;
|
|
expect(packet1.timestamp).toBe(0);
|
|
|
|
const packet3 = (await reader.readNext(packet1))!;
|
|
expect(packet3.sequenceNumber).toBeGreaterThan(packet1.sequenceNumber);
|
|
|
|
const packet4 = (await reader.readNextKey(packet1))!;
|
|
expect(packet4.sequenceNumber).toBeGreaterThan(packet3.sequenceNumber);
|
|
expect(packet4.type).toBe('key');
|
|
|
|
const packet5 = (await reader.readNext(packet3))!;
|
|
expect(packet5.sequenceNumber).toBeGreaterThan(packet3.sequenceNumber);
|
|
expect(packet5.sequenceNumber).toBeLessThan(packet4.sequenceNumber);
|
|
|
|
const packet6 = (await reader.readAt(2.4))!;
|
|
expect(packet6.timestamp).toBeGreaterThan(2);
|
|
expect(packet6.timestamp).toBeLessThanOrEqual(2.4);
|
|
});
|
|
|
|
test('Packet reading throwing after Input disposal', async () => {
|
|
const input = new Input({
|
|
source: new BufferSource(fs.readFileSync(path.join(__dirname, '../public/trim-buck-bunny.mov'))),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
|
|
const first = await reader.readFirst();
|
|
|
|
input.dispose();
|
|
|
|
expect(() => reader.readFirst()).toThrow(InputDisposedError);
|
|
expect(() => reader.readAt(0)).toThrow(InputDisposedError);
|
|
expect(() => reader.readKeyAt(0)).toThrow(InputDisposedError);
|
|
expect(() => reader.readNext(first!)).toThrow(InputDisposedError);
|
|
expect(() => reader.readNextKey(first!)).toThrow(InputDisposedError);
|
|
});
|
|
|
|
test('Packet cursor seeking', async () => {
|
|
using input = new Input({
|
|
source: new FilePathSource(path.join(__dirname, '../public/trim-buck-bunny.mov')),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
const cursor = new PacketCursor(reader);
|
|
|
|
expect(cursor.current).toBe(null);
|
|
|
|
const packet1 = (await cursor.seekToFirst())!;
|
|
expect(packet1).not.toBe(null);
|
|
expect(packet1).toBe(cursor.current);
|
|
expect(packet1.timestamp).toBe(0);
|
|
|
|
const packet2 = (await cursor.seekTo(0.01))!;
|
|
expect(packet1.sequenceNumber).toBe(packet2.sequenceNumber); // Same packet
|
|
|
|
const packet3 = (await cursor.seekTo(0.1))!;
|
|
expect(packet3).toBe(cursor.current);
|
|
expect(packet3.timestamp).toBeGreaterThan(0);
|
|
expect(packet3.sequenceNumber).toBeGreaterThan(packet1.sequenceNumber);
|
|
|
|
const packet4 = (await cursor.seekToKey(0.1))!;
|
|
expect(packet4).toBe(cursor.current);
|
|
expect(packet4.sequenceNumber).toBe(packet1.sequenceNumber);
|
|
|
|
const packet5 = (await cursor.seekTo(Infinity))!;
|
|
expect(packet5).toBe(cursor.current);
|
|
expect(packet5.timestamp).toBe(5);
|
|
|
|
const packet6 = (await cursor.seekTo(-Infinity))!;
|
|
expect(packet6).toBe(cursor.current);
|
|
expect(packet6).toBe(null);
|
|
});
|
|
|
|
test('Packet cursor iteration', async () => {
|
|
using input = new Input({
|
|
source: new FilePathSource(path.join(__dirname, '../public/trim-buck-bunny.mov')),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
const cursor = new PacketCursor(reader);
|
|
|
|
const packet0 = (await cursor.seekToFirst())!;
|
|
expect(cursor.current!.timestamp).toBe(0);
|
|
|
|
const packet1 = (await cursor.next())!;
|
|
expect(packet1.sequenceNumber).toBeGreaterThan(packet0.sequenceNumber);
|
|
expect(packet1).toBe(cursor.current);
|
|
|
|
const packet2 = (await cursor.next())!;
|
|
expect(packet2.sequenceNumber).toBeGreaterThan(packet1.sequenceNumber);
|
|
expect(packet2).toBe(cursor.current);
|
|
|
|
const packet3 = (await cursor.nextKey())!;
|
|
expect(packet3.sequenceNumber).toBeGreaterThan(packet2.sequenceNumber);
|
|
expect(packet3.type).toBe('key');
|
|
expect(packet3).toBe(cursor.current);
|
|
|
|
await cursor.seekTo(Infinity);
|
|
expect(cursor.current).not.toBe(null);
|
|
|
|
const packet4 = await cursor.next();
|
|
expect(packet4).toBe(null);
|
|
expect(packet4).toBe(cursor.current);
|
|
|
|
const packet5 = await cursor.next();
|
|
expect(packet5).toBe(null);
|
|
|
|
await cursor.seekTo(-Infinity);
|
|
expect(cursor.current).toBe(null);
|
|
|
|
const packet6 = (await cursor.next())!;
|
|
expect(packet6.sequenceNumber).toBe(packet0.sequenceNumber);
|
|
expect(packet6).toBe(cursor.current);
|
|
|
|
await cursor.seekTo(-Infinity);
|
|
expect(cursor.current).toBe(null);
|
|
|
|
const packet7 = (await cursor.next())!;
|
|
expect(packet7.sequenceNumber).toBe(packet0.sequenceNumber);
|
|
expect(packet7).toBe(cursor.current);
|
|
|
|
const packet8 = (await cursor.next())!;
|
|
expect(packet8.sequenceNumber).toBeGreaterThan(packet7.sequenceNumber);
|
|
expect(packet8).toBe(cursor.current);
|
|
|
|
await cursor.seekToFirst();
|
|
|
|
let total = 0;
|
|
let lastSeqNum = -Infinity;
|
|
for await (const packet of cursor) {
|
|
if (total === 0) {
|
|
expect(packet.sequenceNumber).toBe(packet0.sequenceNumber);
|
|
}
|
|
|
|
expect(packet.sequenceNumber).toBeGreaterThan(lastSeqNum);
|
|
|
|
lastSeqNum = packet.sequenceNumber;
|
|
total++;
|
|
}
|
|
|
|
expect(total).toBe(121);
|
|
|
|
for await (const _ of cursor) {
|
|
throw new Error('Unreachable');
|
|
}
|
|
|
|
total = 0;
|
|
await cursor.seekTo(1);
|
|
for await (const _ of cursor) {
|
|
total++;
|
|
}
|
|
|
|
expect(total).toBe(97);
|
|
|
|
total = 0;
|
|
await cursor.seekToFirst();
|
|
await cursor.iterate(() => total++);
|
|
|
|
expect(total).toBe(121);
|
|
expect(cursor.current).toBe(null);
|
|
|
|
total = 0;
|
|
await cursor.seekToFirst();
|
|
await cursor.iterate((packet, stop) => {
|
|
if (packet.timestamp === 1) {
|
|
stop();
|
|
return;
|
|
}
|
|
|
|
total++;
|
|
});
|
|
|
|
expect(total).toBe(24);
|
|
expect(cursor.current!.timestamp).toBe(1);
|
|
|
|
await cursor.seekTo(-Infinity);
|
|
total = 0;
|
|
for await (const _ of cursor) total++;
|
|
|
|
expect(total).toBe(121);
|
|
|
|
await cursor.seekTo(-Infinity);
|
|
total = 0;
|
|
await cursor.iterate(() => total++);
|
|
|
|
expect(total).toBe(121);
|
|
|
|
const cursor2 = new PacketCursor(reader);
|
|
const packet9 = (await cursor2.next())!; // Without any prior seeks
|
|
expect(packet9.sequenceNumber).toBe(packet0.sequenceNumber);
|
|
});
|
|
|
|
test('Synchronous packet reading', async () => {
|
|
using input = new Input({
|
|
source: new BufferSource(fs.readFileSync(path.join(__dirname, '../public/trim-buck-bunny.mov'))),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
const cursor = new PacketCursor(reader);
|
|
|
|
expect(reader.readFirst()).not.toBeInstanceOf(Promise);
|
|
|
|
expect(cursor.seekToFirst()).not.toBeInstanceOf(Promise);
|
|
expect(cursor.seekTo(0.1)).not.toBeInstanceOf(Promise);
|
|
expect(cursor.seekToKey(0.1)).not.toBeInstanceOf(Promise);
|
|
expect(cursor.seekTo(2)).not.toBeInstanceOf(Promise);
|
|
expect(cursor.seekTo(Infinity)).not.toBeInstanceOf(Promise);
|
|
expect(cursor.seekTo(-Infinity)).not.toBeInstanceOf(Promise);
|
|
|
|
void cursor.seekToFirst();
|
|
|
|
expect(cursor.next()).not.toBeInstanceOf(Promise);
|
|
});
|
|
|
|
test('Command queuing', async () => {
|
|
using input = new Input({
|
|
source: new FilePathSource(path.join(__dirname, '../public/trim-buck-bunny.mov'), {
|
|
maxCacheSize: 0, // So all commands return promises
|
|
}),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
const cursor = new PacketCursor(reader);
|
|
|
|
expect(cursor.waitUntilIdle()).toBe(null);
|
|
|
|
const commands = [
|
|
cursor.seekToFirst(),
|
|
cursor.next(),
|
|
cursor.next(),
|
|
cursor.seekTo(2.4),
|
|
cursor.next(),
|
|
cursor.nextKey(),
|
|
cursor.waitUntilIdle()!.then(() => cursor.current),
|
|
cursor.nextKey(),
|
|
cursor.nextKey(),
|
|
cursor.next(),
|
|
cursor.seekTo(Infinity),
|
|
cursor.seekTo(-Infinity),
|
|
cursor.seekToKey(2.4),
|
|
];
|
|
|
|
expect(commands.every(x => x instanceof Promise)).toBe(true);
|
|
|
|
const resolved = await promiseAllEnsureOrder(commands);
|
|
|
|
expect(resolved[0]!.timestamp).toBe(0);
|
|
|
|
expect(resolved[1]!.sequenceNumber).toBeGreaterThan(resolved[0]!.sequenceNumber);
|
|
|
|
expect(resolved[2]!.sequenceNumber).toBeGreaterThan(resolved[1]!.sequenceNumber);
|
|
|
|
expect(resolved[3]!.timestamp).toBeGreaterThan(2);
|
|
expect(resolved[3]!.timestamp).toBeLessThanOrEqual(2.4);
|
|
|
|
expect(resolved[4]!.sequenceNumber).toBeGreaterThan(resolved[3]!.sequenceNumber);
|
|
|
|
expect(resolved[5]!.timestamp).toBe(3);
|
|
|
|
expect(resolved[6]!.sequenceNumber).toBe(resolved[5]!.sequenceNumber);
|
|
|
|
expect(resolved[7]!.timestamp).toBe(4);
|
|
|
|
expect(resolved[8]!.timestamp).toBe(5);
|
|
|
|
expect(resolved[9]).toBe(null);
|
|
|
|
expect(resolved[10]!.sequenceNumber).toBe(resolved[8]!.sequenceNumber);
|
|
|
|
expect(resolved[11]).toBe(null);
|
|
|
|
expect(resolved[12]!.timestamp).toBe(2);
|
|
expect(resolved[12]!.type).toBe('key');
|
|
|
|
void cursor.seekTo(1);
|
|
await cursor.iterate((packet, stop) => {
|
|
expect(packet.timestamp).toBe(1);
|
|
stop();
|
|
});
|
|
|
|
void cursor.seekTo(3);
|
|
for await (const packet of cursor) {
|
|
expect(packet.timestamp).toBe(3);
|
|
break;
|
|
}
|
|
});
|
|
|
|
test('verifyKeyPackets with faultily-labeled key frames', async () => {
|
|
using input = new Input({
|
|
source: new FilePathSource(path.join(__dirname, '../public/fucked-keyframes.mp4')),
|
|
formats: ALL_FORMATS,
|
|
});
|
|
|
|
const videoTrack = (await input.getPrimaryVideoTrack())!;
|
|
const reader = new PacketReader(videoTrack);
|
|
|
|
const firstPacket = (await reader.readFirst())!;
|
|
expect(firstPacket.type).toBe('key');
|
|
|
|
const fakeKeyPacket = (await reader.readNextKey(firstPacket))!;
|
|
expect(fakeKeyPacket).not.toBe(null);
|
|
expect(fakeKeyPacket.type).toBe('key'); // Metadata says it's a key frame
|
|
expect(fakeKeyPacket.sequenceNumber).toBeGreaterThan(firstPacket.sequenceNumber);
|
|
|
|
const verifiedPacket = (await reader.readAt(fakeKeyPacket.timestamp, { verifyKeyPackets: true }))!;
|
|
expect(verifiedPacket.sequenceNumber).toBe(fakeKeyPacket.sequenceNumber);
|
|
expect(verifiedPacket.type).toBe('delta'); // After verification, it's actually a delta frame
|
|
|
|
const unverifiedKeyAt = (await reader.readKeyAt(fakeKeyPacket.timestamp))!;
|
|
expect(unverifiedKeyAt.sequenceNumber).toBe(fakeKeyPacket.sequenceNumber);
|
|
expect(unverifiedKeyAt.type).toBe('key');
|
|
|
|
const verifiedKeyAt = (await reader.readKeyAt(fakeKeyPacket.timestamp, { verifyKeyPackets: true }))!;
|
|
expect(verifiedKeyAt.sequenceNumber).toBe(firstPacket.sequenceNumber);
|
|
expect(verifiedKeyAt.type).toBe('key');
|
|
|
|
const unverifiedNextKey = (await reader.readNextKey(firstPacket))!;
|
|
expect(unverifiedNextKey).not.toBe(null);
|
|
expect(unverifiedNextKey.type).toBe('key');
|
|
expect(unverifiedNextKey.sequenceNumber).toBe(fakeKeyPacket.sequenceNumber);
|
|
|
|
const verifiedNextKey = await reader.readNextKey(firstPacket, { verifyKeyPackets: true });
|
|
expect(verifiedNextKey).toBe(null);
|
|
});
|