168 lines
8.6 KiB
Python
168 lines
8.6 KiB
Python
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()
|