]>
jfr.im git - yt-dlp.git/blob - yt_dlp/webvtt.py
2 from __future__
import unicode_literals
, print_function
, division
5 A partial parser for WebVTT segments. Interprets enough of the WebVTT stream
6 to be able to assemble a single stand-alone subtitle file, suitably adjusting
7 timestamps on the way, while everything else is passed through unmodified.
9 Regular expressions based on the W3C WebVTT specification
10 <https://www.w3.org/TR/webvtt1/>. The X-TIMESTAMP-MAP extension is described
11 in RFC 8216 §3.5 <https://tools.ietf.org/html/rfc8216#section-3.5>.
16 from .utils
import int_or_none
24 class _MatchParser(object):
26 An object that maintains the current parsing position and allows
27 conveniently advancing it as syntax elements are successfully parsed.
30 def __init__(self
, string
):
35 if isinstance(r
, compat_Pattern
):
36 return r
.match(self
._data
, self
._pos
)
37 if isinstance(r
, str):
38 if self
._data
.startswith(r
, self
._pos
):
43 def advance(self
, by
):
46 elif isinstance(by
, compat_Match
):
47 amt
= len(by
.group(0))
48 elif isinstance(by
, str):
50 elif isinstance(by
, int):
58 return self
.advance(self
.match(r
))
61 return _MatchChildParser(self
)
64 class _MatchChildParser(_MatchParser
):
66 A child parser state, which advances through the same data as
67 its parent, but has an independent position. This is useful when
68 advancing through syntax elements we might later want to backtrack
72 def __init__(self
, parent
):
73 super(_MatchChildParser
, self
).__init
__(parent
._data
)
74 self
.__parent
= parent
75 self
._pos
= parent
._pos
79 Advance the parent state to the current position of this child state.
81 self
.__parent
._pos
= self
._pos
85 class ParseError(Exception):
86 def __init__(self
, parser
):
87 super(ParseError
, self
).__init
__("Parse error at position %u (near %r)" % (
88 parser
._pos
, parser
._data
[parser
._pos
:parser
._pos
+ 20]
92 _REGEX_TS
= re
.compile(r
'''(?x)
98 _REGEX_EOF
= re
.compile(r
'\Z')
99 _REGEX_NL
= re
.compile(r
'(?:\r\n|[\r\n])')
100 _REGEX_BLANK
= re
.compile(r
'(?:\r\n|[\r\n])+')
105 Convert a parsed WebVTT timestamp (a re.Match obtained from _REGEX_TS)
106 into an MPEG PES timestamp: a tick counter at 90 kHz resolution.
109 h
, min, s
, ms
= ts
.groups()
111 int(h
or 0) * 3600000 + # noqa: W504,E221,E222
112 int(min) * 60000 + # noqa: W504,E221,E222
113 int(s
) * 1000 + # noqa: W504,E221,E222
114 int(ms
) # noqa: W504,E221,E222
120 Convert an MPEG PES timestamp into a WebVTT timestamp.
121 This will lose sub-millisecond precision.
123 msec
= int((ts
+ 45) // 90)
124 secs
, msec
= divmod(msec
, 1000)
125 mins
, secs
= divmod(secs
, 60)
126 hrs
, mins
= divmod(mins
, 60)
127 return '%02u:%02u:%02u.%03u' % (hrs
, mins
, secs
, msec
)
132 An abstract WebVTT block.
135 def __init__(self
, **kwargs
):
136 for key
, val
in kwargs
.items():
137 setattr(self
, key
, val
)
140 def parse(cls
, parser
):
141 m
= parser
.match(cls
._REGEX
)
145 return cls(raw
=m
.group(0))
147 def write_into(self
, stream
):
148 stream
.write(self
.raw
)
151 class HeaderBlock(Block
):
153 A WebVTT block that may only appear in the header part of the file,
154 i.e. before any cue blocks.
160 class Magic(HeaderBlock
):
161 _REGEX
= re
.compile(r
'\ufeff?WEBVTT([ \t][^\r\n]*)?(?:\r\n|[\r\n])')
163 # XXX: The X-TIMESTAMP-MAP extension is described in RFC 8216 §3.5
164 # <https://tools.ietf.org/html/rfc8216#section-3.5>, but the RFC
165 # doesn’t specify the exact grammar nor where in the WebVTT
166 # syntax it should be placed; the below has been devised based
167 # on usage in the wild
169 # And strictly speaking, the presence of this extension violates
170 # the W3C WebVTT spec. Oh well.
172 _REGEX_TSMAP
= re
.compile(r
'X-TIMESTAMP-MAP=')
173 _REGEX_TSMAP_LOCAL
= re
.compile(r
'LOCAL:')
174 _REGEX_TSMAP_MPEGTS
= re
.compile(r
'MPEGTS:([0-9]+)')
177 def __parse_tsmap(cls
, parser
):
178 parser
= parser
.child()
181 m
= parser
.consume(cls
._REGEX
_TSMAP
_LOCAL
)
183 m
= parser
.consume(_REGEX_TS
)
185 raise ParseError(parser
)
188 raise ParseError(parser
)
190 m
= parser
.consume(cls
._REGEX
_TSMAP
_MPEGTS
)
192 mpegts
= int_or_none(m
.group(1))
194 raise ParseError(parser
)
196 raise ParseError(parser
)
197 if parser
.consume(','):
199 if parser
.consume(_REGEX_NL
):
201 raise ParseError(parser
)
207 def parse(cls
, parser
):
208 parser
= parser
.child()
210 m
= parser
.consume(cls
._REGEX
)
212 raise ParseError(parser
)
215 local
, mpegts
= None, None
216 if parser
.consume(cls
._REGEX
_TSMAP
):
217 local
, mpegts
= cls
.__parse
_tsmap
(parser
)
218 if not parser
.consume(_REGEX_NL
):
219 raise ParseError(parser
)
221 return cls(extra
=extra
, mpegts
=mpegts
, local
=local
)
223 def write_into(self
, stream
):
224 stream
.write('WEBVTT')
225 if self
.extra
is not None:
226 stream
.write(self
.extra
)
228 if self
.local
or self
.mpegts
:
229 stream
.write('X-TIMESTAMP-MAP=LOCAL:')
230 stream
.write(_format_ts(self
.local
if self
.local
is not None else 0))
231 stream
.write(',MPEGTS:')
232 stream
.write(str(self
.mpegts
if self
.mpegts
is not None else 0))
237 class StyleBlock(HeaderBlock
):
238 _REGEX
= re
.compile(r
'''(?x)
239 STYLE[\ \t]*(?:\r\n|[\r\n])
240 ((?:(?!-->)[^\r\n])+(?:\r\n|[\r\n]))*
245 class RegionBlock(HeaderBlock
):
246 _REGEX
= re
.compile(r
'''(?x)
248 ((?:(?!-->)[^\r\n])+(?:\r\n|[\r\n]))*
253 class CommentBlock(Block
):
254 _REGEX
= re
.compile(r
'''(?x)
255 NOTE(?:\r\n|[\ \t\r\n])
256 ((?:(?!-->)[^\r\n])+(?:\r\n|[\r\n]))*
261 class CueBlock(Block
):
263 A cue block. The payload is not interpreted.
266 _REGEX_ID
= re
.compile(r
'((?:(?!-->)[^\r\n])+)(?:\r\n|[\r\n])')
267 _REGEX_ARROW
= re
.compile(r
'[ \t]+-->[ \t]+')
268 _REGEX_SETTINGS
= re
.compile(r
'[ \t]+((?:(?!-->)[^\r\n])+)')
269 _REGEX_PAYLOAD
= re
.compile(r
'[^\r\n]+(?:\r\n|[\r\n])?')
272 def parse(cls
, parser
):
273 parser
= parser
.child()
276 m
= parser
.consume(cls
._REGEX
_ID
)
280 m0
= parser
.consume(_REGEX_TS
)
283 if not parser
.consume(cls
._REGEX
_ARROW
):
285 m1
= parser
.consume(_REGEX_TS
)
288 m2
= parser
.consume(cls
._REGEX
_SETTINGS
)
289 if not parser
.consume(_REGEX_NL
):
292 start
= _parse_ts(m0
)
294 settings
= m2
.group(1) if m2
is not None else None
298 m
= parser
.consume(cls
._REGEX
_PAYLOAD
)
301 text
.write(m
.group(0))
306 start
=start
, end
=end
, settings
=settings
,
310 def write_into(self
, stream
):
311 if self
.id is not None:
312 stream
.write(self
.id)
314 stream
.write(_format_ts(self
.start
))
315 stream
.write(' --> ')
316 stream
.write(_format_ts(self
.end
))
317 if self
.settings
is not None:
319 stream
.write(self
.settings
)
321 stream
.write(self
.text
)
331 'settings': self
.settings
,
334 def __eq__(self
, other
):
335 return self
.as_json
== other
.as_json
338 def from_json(cls
, json
):
344 settings
=json
['settings']
347 def hinges(self
, other
):
348 if self
.text
!= other
.text
:
350 if self
.settings
!= other
.settings
:
352 return self
.start
<= self
.end
== other
.start
<= other
.end
355 def parse_fragment(frag_content
):
357 A generator that yields (partially) parsed WebVTT blocks when given
358 a bytes object containing the raw contents of a WebVTT file.
361 parser
= _MatchParser(frag_content
.decode('utf-8'))
363 yield Magic
.parse(parser
)
365 while not parser
.match(_REGEX_EOF
):
366 if parser
.consume(_REGEX_BLANK
):
369 block
= RegionBlock
.parse(parser
)
373 block
= StyleBlock
.parse(parser
)
377 block
= CommentBlock
.parse(parser
)
379 yield block
# XXX: or skip
384 while not parser
.match(_REGEX_EOF
):
385 if parser
.consume(_REGEX_BLANK
):
388 block
= CommentBlock
.parse(parser
)
390 yield block
# XXX: or skip
392 block
= CueBlock
.parse(parser
)
397 raise ParseError(parser
)