threefive

threefive is SCTE-35. threefive Parses SCTE-35 in every available format. MPEGTS, HLS, DASH. Yes.

View the Project on GitHub futzu/threefive

cli lib examples hls encoding sixfix sidecar files xml iodisco.com/scte35

I Asked Google’s Super Advanced Ai about threefive….

scte-ai

SCTE-35 parser, SCTE-35 decoder, SCTE-35 encoder, SCTE-35 injector and SCTE-35 converter.

Latest version is v2.4.95

image

Documentation

####

Latest docs are always available in the python shell


>>>> from threefive import TimeSignal
>>>> help(TimeSignal)

install

Versions and Releases Every time I fix a bug or add a feature, I do a new release.
This makes tracking down bugs and stuff much easier.
Keep up, I do releases for reasons. ```lua a@slow:~/threefive$ threefive version 2.4.81 a@slow:~/threefive$ ``` * __Release__ versions are __odd__. * __Unstable__ testing versions are __even__. --- ![image](https://github.com/user-attachments/assets/caac5f33-204e-47c7-bcdb-1e2d05fdaefb)

cli

lib

online parser

examples

decryption

webvtt

dash

encoding

</details>

Cue Class * src [cue.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/cue.py) * The __threefive.Cue__ class decodes a SCTE35 binary, base64, or hex encoded string. ![image](https://github.com/futzu/scte35-threefive/assets/52701496/5b8dbea3-1d39-48c4-8fbe-de03a53cc1dd) ```py3 class Cue(threefive.base.SCTE35Base) | Cue(data=None, packet_data=None) ``` ```js | __init__(self, data=None, packet_data=None) | data may be packet bites or encoded string | packet_data is a instance passed from a Stream instance ``` * `Cue.decode()` ```js | decode(self) | Cue.decode() parses for SCTE35 data ``` * After Calling cue.decode() the __instance variables can be accessed via dot notation__. ```python3 >>>> cue.command {'calculated_length': 5, 'name': 'Time Signal', 'time_specified_flag': True, 'pts_time': 21695.740089} >>>> cue.command.pts_time 21695.740089 >>>> cue.info_section.table_id '0xfc' ``` * `Cue.get()` ```js | get(self) | Cue.get returns the SCTE-35 Cue | data as a dict of dicts. ``` > `Cue.get() Example` ```python3 >>> from threefive import Cue >>> cue = Cue('0XFC301100000000000000FFFFFF0000004F253396') >>> cue.decode() True >>> cue {'bites': b'\xfc0\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\x00\x00\x00O%3\x96', 'info_section': {'table_id': '0xfc', 'section_syntax_indicator': False, 'private': False, 'sap_type': '0x3', 'sap_details': 'No Sap Type', 'section_length': 17, 'protocol_version': 0, 'encrypted_packet': False, 'encryption_algorithm': 0, 'pts_adjustment_ticks': 0, 'pts_adjustment': 0.0, 'cw_index': '0x0', 'tier': '0xfff', 'splice_command_length': 4095, 'splice_command_type': 0, 'descriptor_loop_length': 0, 'crc': '0x4f253396'}, 'command': {'command_length': None, 'command_type': 0, 'name': 'Splice Null'}, 'descriptors': [], 'packet_data': None} ``` * Cue.get() omits cue.bites and empty values ``` >>> cue.get() {'info_section': {'table_id': '0xfc', 'section_syntax_indicator': False,'private': False, 'sap_type': '0x3', 'sap_details': 'No Sap Type', 'section_length': 17, 'protocol_version': 0, 'encrypted_packet': False, 'encryption_algorithm': 0, 'pts_adjustment_ticks': 0, 'pts_adjustment': 0.0, 'cw_index': '0x0', 'tier': '0xfff', 'splice_command_length': 4095, 'splice_command_type': 0, 'descriptor_loop_length': 0, 'crc': '0x4f253396'}, 'command': {'command_type': 0, 'name': 'Splice Null'}, 'descriptors': []} ``` * `Cue.get_descriptors()` ```js | get_descriptors(self) | Cue.get_descriptors returns a list of | SCTE 35 splice descriptors as dicts. ``` * `Cue.get_json()` ```js | get_json(self) | Cue.get_json returns the Cue instance | data in json. ``` * `Cue.show()` ```js | show(self) | Cue.show prints the Cue as JSON ``` * `Cue.to_stderr()` ```js | to_stderr(self) | Cue.to_stderr prints the Cue ```
Stream Class * src [stream.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/stream.py) * The threefive.__Stream__ class parses __SCTE35__ from __Mpegts__. * Supports: * __File__ and __Http(s)__ and __Udp__ and __Multicast__ protocols. * __Multiple Programs__. * __Multi-Packet PAT, PMT, and SCTE35 tables__. * threefive tries to include __pid__, __program__, anf __pts__ of the SCTE-35 packet. ```js class Stream(builtins.object) | Stream(tsdata, show_null=True) | | Stream class for parsing MPEG-TS data. ``` ```py3 | __init__(self, tsdata, show_null=True) | | tsdata is a file or http, https, | udp or multicast url. | | set show_null=False to exclude Splice Nulls ``` * `Stream.decode(func=show_cue)` ```py3 | decode(self, func=show_cue) | Stream.decode reads self.tsdata to find SCTE35 packets. | func can be set to a custom function that accepts | a threefive.Cue instance as it's only argument. ``` > `Stream.decode Example` ```python3 import sys from threefive import Stream >>>> Stream('plp0.ts').decode() ``` * Pass in custom function * __func__ should match the interface ``` func(cue)``` > `Stream.decode with custom function Example` ```python3 import sys import threefive def display(cue): print(f'\033[92m{cue.packet_data}\033[00m') print(f'{cue.command.name}') def do(): sp = threefive.Stream(tsdata) sp.decode(func = display) if __name__ == '__main__': do() ``` ___ * `Stream.decode_next()` ```js | decode_next(self) | Stream.decode_next returns the next | SCTE35 cue as a threefive.Cue instance. ``` > `Stream.decode_next Example` ```python3 """ Stream.decode_next example. decode_next returns the Cue every time a Cue is found. This uses a while loop to pull the Cues from a mpegts stream. When a Cue is found, if it's a Time Signal, cue.command.command_type=6, print Cue.command. You can filter on any var in the SCTE-35 Cue. """ import sys import threefive from new_reader import reader def do(): arg = sys.argv[1] with reader(arg) as tsdata: st = threefive.Stream(tsdata) while True: cue = st.decode_next() if not cue: return False if cue: if cue.command.command_type ==6: print(cue.command) if __name__ == "__main__": do() ``` * `Stream.proxy(func = show_cue)` * Writes all packets to sys.stdout. * Writes scte35 data to sys.stderr. ```js | decode(self, func=show_cue_stderr) | Stream.decode_proxy writes all ts packets are written to stdout | for piping into another program like mplayer. | SCTE-35 cues are printed to stderr. ``` > `Stream.proxy Example` ```python3 import threefive sp = threefive.Stream('https://futzu.com/xaa.ts') sp.decode_proxy() ``` * Pipe to mplayer ```bash $ python3 proxy.py | mplayer - ``` ___ * `Stream.show()` ```js | show(self) | List programs and streams and info for MPEGTS ``` > `Stream.show() Example` ```python3 >>>> from threefive import Stream >>>> Stream('https://slo.me/plp0.ts').show() ``` ```js Service: fancy ˹ Provider: fu-corp Pcr Pid: 1051[0x41b] Streams: Pid: 1051[0x41b] Type: 0x1b AVC Video Pid: 1052[0x41c] Type: 0x3 MP2 Audio Pid: 1054[0x41e] Type: 0x6 PES Packets/Private Data Pid: 1055[0x41f] Type: 0x86 SCTE35 Data ```
Need to verify your splice points? ![image](https://github.com/user-attachments/assets/2581053a-e373-434e-9e06-32ace453aa02) * Try [cue2vtt.py](https://github.com/futzu/scte35-threefive/blob/master/examples/stream/cue2vtt.py) in the examples. * cue2vtt.py creates webvtt subtitles out of SCTE-35 Cue data * use it like this ```rebol pypy3 cue2vtt.py video.ts | mplayer video.ts -sub - ``` ---
threefive is now addressable TV compatible ```smalltalk "tag": 2, "descriptor_length": 31, "name": "Segmentation Descriptor", "identifier": "CUEI", "components": [], "segmentation_event_id": "0x065eff", "segmentation_event_cancel_indicator": false, "segmentation_event_id_compliance_indicator": true, "program_segmentation_flag": true, "segmentation_duration_flag": false, "delivery_not_restricted_flag": true, "segmentation_message": "Call Ad Server", < --- Boom "segmentation_upid_type": 12, "segmentation_upid_type_name": "MPU", "segmentation_upid_length": 16, "segmentation_upid": { "format_identifier": "ADFR", <--- Boom "private_data": "0x0133f10134b04f065e060220", "version": 1, <---- Boom "channel_identifier": "0x33f1", <---- Boom "date": 20230223, <---- Boom "break_code": 1630, <---- Boom "duration": "0x602" <---- Boom }, "segmentation_type_id": 2, <---- Boom "segment_num": 0, "segments_expected": 0 }, ``` ---
Custom charsets for UPIDS aka upids.charset `Specify a charset for Upid data by setting threefive.upids.charset` [`issue #55`](https://github.com/futzu/scte35-threefive/issues/55) * default charset is ascii * python charsets info [Here](https://docs.python.org/3/library/codecs.html) * setting charset to None will return raw bytes. #### Example Usage: ```lua >>> from threefive import Cue,upids >>> i="/DBKAAAAAAAAAP/wBQb+YtC8/AA0AiZDVUVJAAAD6X/CAAD3W3ACEmJibG5kcHBobkQCAsGDpQIAAAAAAAEKQ1VFSRSAIyowMljRk9c=" >>> upids.charset 'ascii' >>> cue=Cue(i) >>> cue.decode() ascii True >>> cue.descriptors[0].segmentation_upid 'bblndpphnD\x02\x02���\x02\x00\x00' >>> upids.charset="utf16" >>> cue.decode() utf16 True >>> cue.descriptors[0].segmentation_upid '扢湬灤桰䑮Ȃ菁ʥ\x00' ```
Custom Private Splice Descriptors ( new! ) ### threefive now supports custom private splice descriptors, right out the box. * The first byte of the descriptor is read as an int for the Descriptor tag * The second byte is read as an int for the desciptor length * The next four bytes are read as ASCII for the Identifier * remanining bytes are returned as private data ```js from threefive import Cue, TimeSignal from threefive.descriptors import SpliceDescriptor ``` * make a Cue ```smalltalk c = Cue() ``` * add a Time Signal ```smalltalk c.command = TimeSignal() c.command.time_specified_flag=True c.command.pts_time=1234.567890 ``` * add Splice Descriptor ```smalltalk sd = SpliceDescriptor() sd.tag = 47 sd.identifier ='fufu' sd.private_data = b'threefive kicks ass' c.descriptors.append(sd) ``` * encode ```smalltalk c.encode() '/DAvAAAAAAAAAP/wBQb+Bp9rxgAZLxdmdWZ1dGhyZWVmaXZlIGtpY2tzIGFzc1m+EsU=' ``` * show ```smalltalk c.show() { "info_section": { "table_id": "0xfc", "section_syntax_indicator": false, "private": false, "sap_type": "0x03", "sap_details": "No Sap Type", "section_length": 47, "protocol_version": 0, "encrypted_packet": false, "encryption_algorithm": 0, "pts_adjustment_ticks": 0, "cw_index": "0x0", "tier": "0xfff", "splice_command_length": 5, "splice_command_type": 6, "descriptor_loop_length": 25, "crc": "0x59be12c5" }, "command": { "command_length": 5, "command_type": 6, "name": "Time Signal", "time_specified_flag": true, "pts_time": 1234.56789, "pts_time_ticks": 111111110 }, "descriptors": [ { "tag": 47, "descriptor_length": 23, "identifier": "fufu", "private_data": [ 116, 104, 114, 101, 101, 102, 105, 118, 101, 32, 107, 105, 99, 107, 115, 32, 97, 115, 115 ] } ] } ``` * the custom Splice Descriptor ```js c.descriptors[0] {'tag': 47, 'descriptor_length': 23, 'name': None, 'identifier': 'fufu', 'bites': None, 'provider_avail_id': None, 'components': None, 'private_data': b'threefive kicks ass'} ``` * Cool dictionaary comprehension to print the Splice Descriptor with only relevant values ```js {print(f'{k} = {v}') for k,v in vars(c.descriptors[0]).items() if v is not None} tag = 47 descriptor_length = 23 identifier = fufu private_data = b'threefive kicks ass' ```

Powered by threefive


x9k3: SCTE-35 HLS Segmenter and Cue Inserter.
m3ufu: SCTE-35 m3u8 Parser.
adbreak2 a cli tool that quickly and easily generates SCTE-35 Cues for HLS and stuff.
Ultra Mega Zoom Zoom ABR HLS segmenter and SCTE-35 inserter.
POIS Server is Super Cool.
bpkio-cli: A command line interface to the broadpeak.io APIs.
amt-play uses x9k3.

threefive | more —


Diagram of a threefive SCTE-35 Cue.
ffmpeg and threefive and SCTE35 and Stream Type 0x6 bin data.
Issues and Bugs and Feature Requests will be considered. Please don’t make me regret it.
NEW! threefive now has experimental DVB DAS Support ETSI TS 103 752-1

image