diff --git a/devine/core/drm/widevine.py b/devine/core/drm/widevine.py
index aeb0a84..d31ed46 100644
--- a/devine/core/drm/widevine.py
+++ b/devine/core/drm/widevine.py
@@ -87,7 +87,7 @@ class Widevine:
if x and x.keyformat and x.keyformat.lower() == WidevineCdm.urn
)
- init_data = track.get_init_segment(session)
+ init_data = track.get_init_segment(session=session)
if init_data:
# try get via ffprobe, needed for non mp4 data e.g. WEBM from Google Play
probe = ffprobe(init_data)
diff --git a/devine/core/tracks/track.py b/devine/core/tracks/track.py
index c79c51d..e0d12f1 100644
--- a/devine/core/tracks/track.py
+++ b/devine/core/tracks/track.py
@@ -5,7 +5,6 @@ from enum import Enum
from pathlib import Path
from typing import Any, Callable, Iterable, Optional, Union
-import m3u8
import requests
from langcodes import Language
@@ -85,48 +84,91 @@ class Track:
extra_parts.append(TERRITORY_MAP.get(territory, territory))
return ", ".join(extra_parts) or None
- def get_init_segment(self, session: Optional[requests.Session] = None) -> bytes:
+ def get_init_segment(
+ self,
+ fallback_size: int = 20000,
+ url: Optional[str] = None,
+ byte_range: Optional[str] = None,
+ session: Optional[requests.Session] = None
+ ) -> bytes:
"""
Get the Track's Initial Segment Data Stream.
- If the Track URL is not detected to be an init segment, it will download
- up to the first 20,000 (20KB) bytes only.
+
+ HLS and DASH tracks must explicitly provide a URL to the init segment or file.
+ Providing the byte-range for the init segment is recommended where possible.
+
+ If `byte_range` is not set, it will make a HEAD request and check the size of
+ the file. If the size could not be determined, it will download up to the first
+ 20KB only, which should contain the entirety of the init segment. You may
+ override this by changing the `fallback_size`.
+
+ The default fallback_size of 20000 (20KB) is a tried-and-tested value that
+ seems to work well across the board.
+
+ Parameters:
+ fallback_size: Size to assume as the content length if byte-range is not
+ used and the content size could not be determined. 20000 (20KB) or
+ higher is recommended.
+ url: Explicit init map or file URL to probe from.
+ byte_range: Range of bytes to download from the explicit or implicit URL.
+ session: Session context, e.g., authorization and headers.
"""
if not session:
session = requests.Session()
- url = None
- is_init_stream = False
-
- if self.descriptor == self.Descriptor.M3U:
- master = m3u8.loads(session.get(self.url).text, uri=self.url)
- for segment in master.segments:
- if not segment.init_section:
- continue
- # skip any segment that would be skipped from the download
- # as we cant consider these a true initial segment
- if callable(self.OnSegmentFilter) and self.OnSegmentFilter(segment):
- continue
- url = ("" if re.match("^https?://", segment.init_section.uri) else segment.init_section.base_uri)
- url += segment.init_section.uri
- is_init_stream = True
- break
+ if self.descriptor != self.Descriptor.URL and not url:
+ # We cannot know which init map from the HLS or DASH playlist is actually used.
+ # For DASH this could be from any adaptation set, any period, e.t.c.
+ # For HLS we could make some assumptions, but it's best that it is explicitly provided.
+ raise ValueError(
+ f"An explicit URL to an init map or file must be provided for {self.descriptor.name} tracks."
+ )
+ url = url or self.url
if not url:
- url = self.url
+ raise ValueError("The track must have an URL to point towards it's data.")
- if isinstance(url, list):
- url = url[0]
- is_init_stream = True
+ content_length = fallback_size
- if is_init_stream:
- return session.get(url).content
+ if byte_range:
+ if not isinstance(byte_range, str):
+ raise TypeError(f"Expected byte_range to be a str, not {byte_range!r}")
+ if not re.match(r"^\d+-\d+$", byte_range):
+ raise ValueError(f"The value of byte_range is unrecognized: '{byte_range}'")
+ start, end = byte_range.split("-")
+ if start > end:
+ raise ValueError(f"The start range cannot be greater than the end range: {start}>{end}")
+ else:
+ size_test = session.head(url)
+ if "Content-Length" in size_test.headers:
+ content_length = int(size_test.headers['Content-Length'])
+ range_test = session.head(url, headers={"Range": "bytes=0-1"})
+ if range_test.status_code == 206:
+ if content_length < 100000: # 100KB limit
+ # if it supports it, and is less than 100KB, use byte-range
+ byte_range = f"0-{content_length-1}"
- # likely a full single-file download, get first 20k bytes
- with session.get(url, stream=True) as s:
- # assuming enough to contain the pssh/kid
- for chunk in s.iter_content(20000):
- # we only want the first chunk
- return chunk
+ if byte_range:
+ res = session.get(
+ url=url,
+ headers={
+ "Range": f"bytes={byte_range}"
+ }
+ )
+ res.raise_for_status()
+ init_data = res.content
+ else:
+ # Take advantage of streaming support to take just the first n bytes
+ # This is a hacky alternative to HTTP's Range on unsupported servers
+ init_data = None
+ with session.get(url, stream=True) as s:
+ for chunk in s.iter_content(content_length):
+ init_data = chunk
+ break
+ if not init_data:
+ raise ValueError(f"Failed to read {content_length} bytes from the track URI.")
+
+ return init_data
def delete(self) -> None:
if self.path: