beffroi-tools/tests/test_playback.py

168 lines
8.6 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

import contextlib
import io
import json
from pathlib import Path
import tempfile
import unittest
from unittest.mock import patch
import zipfile
from tools import pptx_videos as videos
from tools.playback import P14, time_offset
def picture(shape_id, trim=''):
return f'''
<p:pic><p:nvPicPr><p:cNvPr id="{shape_id}" name="Video"/>
<p:nvPr><a:videoFile r:link="legacy"/>
<p:extLst><p:ext uri="media"><p14:media r:embed="media">{trim}</p14:media></p:ext></p:extLst>
</p:nvPr></p:nvPicPr></p:pic>'''
def timing(shape_id, attrs='', children='', media_attrs=''):
return f'''<p:video><p:cMediaNode {media_attrs}>
<p:cTn id="{shape_id}" {attrs}>{children}</p:cTn>
<p:tgtEl><p:spTgt spid="{shape_id}"/></p:tgtEl>
</p:cMediaNode></p:video>'''
class PlaybackTests(unittest.TestCase):
def setUp(self):
self.temp = tempfile.TemporaryDirectory()
self.addCleanup(self.temp.cleanup)
self.root = Path(self.temp.name)
def deck(self, slides):
path = self.root / 'trimmed.pptx'
with zipfile.ZipFile(path, 'w') as archive:
archive.writestr('ppt/media/shared.mp4', b'media')
for index, (shapes, animation) in enumerate(slides, 1):
archive.writestr(f'ppt/slides/slide{index}.xml', f'''
<p:sld xmlns:p="{videos.P_NS}" xmlns:p14="{P14}"
xmlns:a="http://schemas.openxmlformats.org/drawingml/2006/main" xmlns:r="{videos.R_NS}">
<p:cSld><p:spTree>{shapes}</p:spTree></p:cSld>
<p:timing><p:tnLst>{animation}</p:tnLst></p:timing>
</p:sld>''')
archive.writestr(f'ppt/slides/_rels/slide{index}.xml.rels', f'''
<Relationships xmlns="{videos.REL_NS}">
<Relationship Id="legacy" Target="../media/shared.mp4" Type="example/video"/>
<Relationship Id="media" Target="../media/shared.mp4" Type="example/media"/>
</Relationships>''')
return path
def report(self, slides, duration=10):
path = self.deck(slides)
with zipfile.ZipFile(path) as archive:
parts, uses, external = videos.discover(archive)
settings = videos.playback_settings(archive, parts)
return videos.report_data(path, [('ppt/media/shared.mp4', 'shared.mp4', 5, duration, '32×24', 'mpeg4')],
uses, external, self.root, settings)
def test_time_offset_units_and_invalid_values(self):
for value, expected in [('1500', 1.5), ('1.25s', 1.25), ('1min', 60), ('0.5h', 1800),
('250ms', .25), ('1000µs', .001), ('1000μs', .001), ('1000000ns', .001)]:
self.assertAlmostEqual(time_offset(value), expected)
for value in ('-1', 'NaN', 'Infinity', '1:30', '2seconds', ''):
with self.subTest(value=value), self.assertRaises(ValueError):
time_offset(value)
def test_trim_end_is_amount_removed_not_end_timestamp(self):
data = self.report([(picture('2', '<p14:trim st="1500" end="2s"/>'),
timing('2', 'dur="indefinite"'))])
self.assertEqual(len(data['playbacks']), 1) # legacy + p14 references are deduplicated
playback = data['playbacks'][0]
self.assertEqual(playback['duration_seconds'], 6.5)
self.assertEqual(playback['original_duration_seconds'], 10)
self.assertEqual(playback['trim_start_seconds'], 1.5)
self.assertEqual(playback['trim_end_seconds'], 2)
self.assertEqual(playback['playback_status'], 'trimmed')
event = next(iter(json.loads(videos.render_report(data, 'ontime'))['rundowns']['default']['entries'].values()))
self.assertEqual(event['duration'], 6500)
def test_distinct_trims_on_same_slide_and_other_slides(self):
data = self.report([
(picture('2', '<p14:trim st="1s"/>') + picture('3', '<p14:trim end="2s"/>'), ''),
(picture('2', '<p14:trim st="1s" end="2s"/>'), ''),
])
self.assertEqual([p['duration_seconds'] for p in data['playbacks']], [9, 8, 7])
self.assertEqual(data['embedded_videos'], 1)
self.assertEqual(data['total_size_bytes'], 5)
self.assertEqual(data['total_duration_seconds'], 24)
self.assertEqual(data['total_media_duration_seconds'], 10)
events = json.loads(videos.render_report(data, 'ontime'))['rundowns']['default']['entries']
self.assertEqual(len(events), 3)
self.assertEqual([e['duration'] for e in events.values()], [9000, 8000, 7000])
def test_loop_remains_in_all_reports_but_not_ontime_or_total(self):
data = self.report([
(picture('2'), timing('2', 'repeatCount="indefinite" dur="indefinite"')),
(picture('2', '<p14:trim st="1s"/>'), timing('2', 'dur="indefinite"')),
])
self.assertEqual(data['playbacks'][0]['playback_status'], 'looping')
self.assertIsNone(data['playbacks'][0]['duration_seconds'])
self.assertEqual(data['total_duration_seconds'], 9)
for format in ('md', 'txt', 'html', 'typst', 'pdf-dense'):
with self.subTest(format=format):
self.assertIn('Looping', videos.render_report(data, format))
project = json.loads(videos.render_report(data, 'ontime'))
events = list(project['rundowns']['default']['entries'].values())
self.assertEqual(len(events), 1)
self.assertEqual(events[0]['cue'], 'Slide 2')
self.assertEqual(events[0]['timeStart'], 0)
self.assertEqual(events[0]['duration'], 9000)
def test_only_loops_produce_empty_ontime_rundown(self):
data = self.report([(picture('2'), timing('2', 'repeatCount="2000"'))])
project = json.loads(videos.render_report(data, 'ontime'))
self.assertEqual(project['rundowns']['default']['order'], [])
self.assertEqual(project['rundowns']['default']['entries'], {})
def test_unsupported_timing_is_not_exported(self):
cases = [
timing('2', 'spd="200000"'),
timing('2', 'autoRev="1"'),
timing('2', 'dur="3000"'),
timing('2', children='<p:endCondLst><p:cond evt="onClick"/></p:endCondLst>'),
timing('2', media_attrs='numSld="2"'),
]
for animation in cases:
with self.subTest(animation=animation):
data = self.report([(picture('2'), animation)])
self.assertEqual(data['playbacks'][0]['playback_status'], 'custom-timing')
self.assertIsNone(data['playbacks'][0]['duration_seconds'])
project = json.loads(videos.render_report(data, 'ontime'))
self.assertEqual(project['rundowns']['default']['order'], [])
def test_inherited_repeat_and_unrelated_timing(self):
repeated = '<p:par><p:cTn repeatCount="indefinite"><p:childTnLst>' + timing('2') + '</p:childTnLst></p:cTn></p:par>'
self.assertEqual(self.report([(picture('2'), repeated)])['playbacks'][0]['playback_status'], 'looping')
unrelated = timing('99', 'repeatCount="indefinite"')
self.assertEqual(self.report([(picture('2'), unrelated)])['playbacks'][0]['duration_seconds'], 10)
def test_invalid_trim_is_visible_and_excluded(self):
for trim in ('st="-1"', 'end="NaN"', 'st="8s" end="3s"', 'st="10s"'):
with self.subTest(trim=trim):
data = self.report([(picture('2', f'<p14:trim {trim}/>'), '')])
self.assertEqual(data['playbacks'][0]['playback_status'], 'invalid-trim')
self.assertIn('Invalid trim', videos.render_report(data, 'md'))
project = json.loads(videos.render_report(data, 'ontime'))
self.assertEqual(project['rundowns']['default']['entries'], {})
def test_end_to_end_timings_only_uses_trim_without_modifying_media(self):
source = self.deck([(picture('2', '<p14:trim st="1s" end="2s"/>'), '')])
with patch('sys.argv', ['pptx_videos.py', str(source), '--timings-only', '--report', 'json,ontime']), \
patch.object(videos.shutil, 'which', return_value='/ffprobe'), \
patch.object(videos, 'probe', return_value=(10, '32×24', 'mpeg4')), \
contextlib.redirect_stdout(io.StringIO()):
self.assertEqual(videos.main(), 0)
output = self.root / 'trimmed_videos'
self.assertFalse((output / 'videos').exists())
data = json.loads((output / 'reports/timings.json').read_text())
self.assertEqual(data['videos'][0]['duration_seconds'], 10)
self.assertEqual(data['playbacks'][0]['duration_seconds'], 7)
self.assertEqual(data['playbacks'][0]['original_duration_seconds'], 10)
if __name__ == '__main__':
unittest.main()