148 |
149 | >>>> ad.provider_avail_id = 1234
150 |
151 | >>>> ad.encode()
152 | b'CUEI\x00\x00\x04\xd2' <--- encode returns a byte string when it works
153 | >>>>
154 |
155 | ```
156 | * Add the AvailDescriptor to the Cue.
157 | * Cue.descriptors is a list, so append it.
158 | ```py3
159 | >>>> cue.descriptors.append(ad)
160 | >>>> cue.encode()
161 | '/DAgAAAAAAAAAP/wBQb+Qjo1vQAKAAhDVUVJAAAE0iVuWvA=' <---- Base64 string
162 | ```
163 | * modify the AvailDescriptor and add another Descriptor
164 | ```py3
165 | >>>> ad.provider_avail_id = 5678
166 | >>>> ad.show()
167 | {
168 | "tag": 0,
169 | "descriptor_length": 8,
170 | "name": "Avail Descriptor",
171 | "identifier": "CUEI",
172 | "provider_avail_id": 5678
173 | }
174 | >>>> cue.descriptors.append(ad)
175 | >>>> len(cue.descriptors)
176 | 2
177 | ```
178 | * You can also encode Cue to hex, or int.
179 | ```py3
180 | >>>> cue.encode2hex()
181 | '0xfc302a00000000000000fff00506fe423a35bd00140008435545490000162e0008435545490000162e7cf13378'
182 | >>>> cue.encode2int()
183 | 2313572608209932854073470233617156645467305914531507959339025453988506820473289879370790529590385607701508984
184 | ```
185 | * Everything in a Cue works of dot notation, if you want to change PTS, change it.
186 | ```py3
187 | >>>> cue.command.pts_time
188 | 12345.6789
189 | >>>> cue.command.pts_time=999.9987
190 | >>>> cue.encode()
191 | '/DAqAAAAAAAAAP/wBQb+BV1KCwAUAAhDVUVJAAAWLgAIQ1VFSQAAFi7SdffT'
192 | ```
193 |
--------------------------------------------------------------------------------
/prog.md:
--------------------------------------------------------------------------------
1 | Mpegts Multicast in three lines of code.
2 |
3 | ```python3
4 | import threefive
5 |
6 | strm = threefive.Stream('udp://@239.35.0.35:1234')
7 | strm.decode()
8 | ````
9 | _(need an easy multicast server?_ [gumd](https://github.com/futzu/gumd) )
10 |
11 | ---
12 |
13 | Mpegts over Https in three lines of code.
17 |
18 |
19 | ```python3
20 | import threefive
21 | strm = threefive.Stream('https://iodisco.com/ch1/ready.ts')
22 | strm.decode()
23 | ```
24 |
25 |
26 | Base64 in five lines of code.
30 |
31 |
32 | ```python3
33 | >>> from threefive import Cue
34 | >>> stuff = '/DAvAAAAAAAA///wBQb+dGKQoAAZAhdDVUVJSAAAjn+fCAgAAAAALKChijUCAKnMZ1g='
35 | >>> cue=Cue(stuff)
36 | >>> cue.decode()
37 | True
38 | >>> cue.show()
39 |
40 | ```
41 | ---
42 | Bytes in five lines of code.
45 |
46 | ```python3
47 | >>> import threefive
48 |
49 | >>> stuff = b'\xfc0\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\x00\x00\x00O%3\x96'
50 | >>> cue=Cue(stuff)
51 | >>> cue.decode()
52 | True
53 | >>> cue.show()
54 | ```
55 | ---
56 |
57 |
58 | Hex in 4 lines of code.
63 |
64 |
65 | ```python3
66 | import threefive
67 |
68 | cue = threefive.Cue("0XFC301100000000000000FFFFFF0000004F253396")
69 | cue.decode()
70 | cue.show()
71 | ```
72 |
73 | ---
74 |
75 |
designed for processing HLS segments.
3 |
4 |
5 | * Segment Class Specific Features:
6 | * Decryption of AES Encrypted MPEGTS.
7 | * Segment.cues a list of SCTE35 cues found in the segment.
8 | ---
9 | * Usage:
10 |
11 | ```lua
12 |
13 | from threefive import Segment
14 |
15 | uri = "https://example.com/1.ts"
16 | seg = Segment(uri)
17 | seg.decode()
18 |
19 | # Make a list comprehension of cues found in the segment.
20 | data = [cue.encode() for cue in seg.cues]
21 | print(data)
22 |
23 | ['/DARAAAAAAAAAP/wAAAAAHpPv/8=',
24 | '/DAvAAAAAAAAAP/wFAUAAAKWf+//4WoauH4BTFYgAAEAAAAKAAhDVUVJAAAAAOv1oqc=']
25 |
26 | ```
27 |
28 | * For aes encrypted files
29 |
30 |
31 | ```lua
32 | from threefive import Segment
33 |
34 | key = "https://example.com/aes.key"
35 | IV=0x998C575D24F514AEC84EDC5CABCCDB81
36 | uri = "https://example.com/aes-1.ts"
37 |
38 | seg = Segment(uri,key_uri=key, iv=IV)
39 | seg.decode()
40 |
41 | # make a dictionary comprehension of pts and base64 encoded cues
42 |
43 | data = {cue.packet_data.pts:cue.encode() for cue in seg.cues}
44 |
45 | print(data)
46 |
47 | { 89718.451333: '/DARAAAAAAAAAP/wAAAAAHpPv/8=',
48 | 89730.281789: '/DAvAAAAAAAAAP/wFAUAAAKWf+//4WoauH4BTFYgAAEAAAAKAAhDVUVJAAAAAOv1oqc='}
49 | ```
50 |
51 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python3
2 |
3 | import setuptools
4 |
5 | with open("README.md", "r", encoding="utf-8") as fh:
6 | readme = fh.read()
7 |
8 | with open("threefive/version.py","r", encoding="utf-8") as latest:
9 | version = latest.read().split("'")[1]
10 |
11 | setuptools.setup(
12 | name="threefive",
13 | version=version,
14 | author="Adrian of Doom, and the Fine Folks at Fu Corp.",
15 | author_email="spam@iodisco.com",
16 | description="The Undisputed Heavyweight Champion of SCTE-35. The Belts have been Unified.",
17 | long_description=readme,
18 | long_description_content_type="text/markdown",
19 | url="https://github.com/futzu/threefive",
20 | install_requires=[
21 | 'iframes >= 0.0.7',
22 | 'm3ufu >= 0.0.89',
23 | 'new_reader >= 0.1.13',
24 | 'sideways >= 0.0.23',
25 | "pyaes",
26 | ],
27 |
28 | scripts=['bin/threefive'],
29 | packages=setuptools.find_packages(),
30 | classifiers=[
31 | "License :: OSI Approved :: MIT License",
32 | "Operating System :: OS Independent",
33 | "Programming Language :: Python :: 3.6",
34 | "Programming Language :: Python :: Implementation :: PyPy",
35 | "Programming Language :: Python :: Implementation :: CPython",
36 | ],
37 | python_requires=">=3.6",
38 | )
39 |
--------------------------------------------------------------------------------
/sidecar.md:
--------------------------------------------------------------------------------
1 |
2 | ## Sidecar Files
3 | * Sidecar files are an easy way to insert SCTE-35 into MPEGTS streams or HLS manifests. It's a simplier SCTE-104.
4 | ```js
5 | a@debian:~/x9k3$ cat sidecar.txt
6 |
7 | 38103.868589, /DAxAAAAAAAAAP/wFAUAAABdf+/+zHRtOn4Ae6DOAAAAAAAMAQpDVUVJsZ8xMjEqLYemJQ==
8 | 38199.918911, /DAsAAAAAAAAAP/wDwUAAABef0/+zPACTQAAAAAADAEKQ1VFSbGfMTIxIxGolm0=
9 | ```
10 | * line format for sidecar file is __insert_pts, cue__ ,
11 | * like `38103.868589, /DAxAAAAAAAAAP/wFAUAAABdf+/+zHRtOn4Ae6DOAAAAAAAMAQpDVUVJsZ8xMjEqLYemJQ==`
12 |
13 | * pts is the insert time for the cue, cue can be base64,hex, int, or bytes.
14 |
15 | * The __insert_pts has to be valid for the video__, meaning if your insert_pts is 38103.868589, the video PTS has to be
16 | less than 38103.868589 for the cue to be inserted.
17 |
18 | * [adbreak2](https://github.com/futzu/adbreak2) can be used to generate splice inserts for sidecar files.
19 |
20 | * Generate a "CUE-OUT" and "CUE-IN" with adbreak2
21 | ```js
22 | a@fu:~/cuei$ adbreak2 --duration 240 --event-id=1234 --pts 1234.567890 --sidecar my_sidecar.txt
23 |
24 | Writing to sidecar file: my_sidecar.txt
25 |
26 | CUE-OUT PTS:1234.567889 Id:1234 Duration: 240.0
27 | CUE-IN PTS:1474.567889 Id:1235
28 |
29 | a@fu:~/cuei$ cat my_sidecar.txt
30 | 1234.56789,/DAlAAAAAAAAAP/wFAUAAATSf+/+Bp9rxv4BSZcABNIAAAAA9RqQjw==
31 | 1474.56789,/DAgAAAAAAAAAP/wDwUAAATTf0/+B+kCxgTTAAAAALukcWw=
32 |
33 | ```
34 |
35 | * Sidecar files can also be generated by threefive
36 | * Generate a sidecar file from an existing video
37 | ```py3
38 | threefive sidecar video.ts
39 | ```
40 | * Will generate a sidecar file named sidecar.txt with the Cues from video.ts
41 |
42 | * Insert SCTE-35 Cues from a sidecar file into an mpegts file.
43 | * threefive inject _[input video]_ with _[sidecar file]_ at _[pid of new SCTE-35 stream]_
44 | ```py3
45 | a@fu:~/build/SCTE35_threefive$ threefive inject video.ts with ~/sidecar.txt at 777
46 |
47 | Output File: superkabuki-video.ts
48 | PMT Section Length: 60
49 | Program Number: 1
50 | PCR PID: 256
51 | Program Info Length: 6
52 |
53 | Added Registration Descriptor:
54 | b'\x05\x04CUEI'
55 |
56 | Found Streams:
57 | Stream Type: 0x1b PID: 256 EI Len: 0
58 | Stream Type: 0xf PID: 257 EI Len: 6
59 | Stream Type: 0x86 PID: 258 EI Len: 0
60 | Stream Type: 0x15 PID: 259 EI Len: 15
61 |
62 | Added Stream:
63 | Stream Type: 0x86 PID: 777 EI Len: 0
64 |
65 | Inserted Cue:
66 | @72668.9952, /DAgAAAAAAAAAP/wDwUAAAABf//+AA27oAABAAAAANwB3tE=
67 |
68 | Inserted Cue:
69 | @72670.9972, /DAgAAAAAAAAAP/wDwUAAAABf//+AKTLgAABAAAAANaNPVc=
70 |
71 | Inserted Cue:
72 | @72672.9992, /DAgAAAAAAAAAP/wDwUAAAABf//+AFJlwAABAAAAAMOOklg=
73 |
74 | Inserted Cue:
75 | @72675.0012, /DAgAAAAAAAAAP/wDwUAAAABf//+AA27oAABAAAAANwB3tE=
76 |
77 | Inserted Cue:
78 | @72677.0032, /DAgAAAAAAAAAP/wDwUAAAABf//+AKTLgAABAAAAANaNPVc=
79 |
80 | Inserted Cue:
81 | @72679.0052, /DAgAAAAAAAAAP/wDwUAAAABf//+AFJlwAABAAAAAMOOklg=
82 |
83 | Inserted Cue:
84 | @72681.0072, /DAgAAAAAAAAAP/wDwUAAAABf//+AA27oAABAAAAANwB3tE=
85 | a@fu:~/build/SCTE35_threefive$
86 | ```
87 | * output filename will be __superkabuki-video.ts__
88 |
89 |
--------------------------------------------------------------------------------
/speedtest.md:
--------------------------------------------------------------------------------
1 | # `threefive + Python3` VS. `threefive + pypy3` VS. `tsduck in C++` VS. `cuei in Go.`
2 |
3 | > Q. Why only use __threefive, tsduck and cuei__? What about other SCTE-35 parsers?
4 |
5 | > A. To be honest, they are very few other parsers that will parse SCTE-35 from MPEGTS, here are three that were excluded and why.
6 | >
7 |
8 | 1. __lib BitStream from the VLC folks__. Fast parser, but incomplete SCTE-35 Data last time I used it, and it requires writing about 500 lines of code to parse SCTE-35.
9 | 2. __gstreamer__ I believe it will parse SCTE-35, but I spent a few hours trying to figure out how to do it and I have no idea how to even run gstreamer, much less parse SCTE-35 with it.
10 | 3. __Comcast GOTS__ has about 13,000 lines of code, and requires you write about 300 more to parse SCTE-35, and I'm not exactly sure how to use it.
11 |
12 | # The Contestants
13 |
14 | 1. the __threefive cli__ tool running on __python3__.
15 | 2. the __threeefive cli__ tool running on pypy3.
16 | 3. the __tsduck cli__ using the __SpliceMonitor__ plugin.
17 | 4. the __cuei library__ and __ten lines of code__ to make a cli tool.
18 |
19 |
20 | # The File
21 | ```rebol
22 | a@slow:~/cuei$ ls -alh ../v2.ts
23 | -rw-r--r-- 1 a a 4.9G Mar 8 04:03 ../v2.ts
24 | ```
25 | * I used [SuperKabuki](https://github.com/futzu/superkabuki) to insert 14,862 SCTE-35 Time Signals
26 | ---
27 | ### Test 1: `threefive` with `Python 3.11.2`
28 |
29 | ```smalltalk
30 | a@slow:~/cuei$ time threefive ../v2.ts 2>&1 | grep sap_type | wc -l
31 | 14862
32 |
33 | real 0m8.600s
34 | user 0m8.026s
35 | sys 0m0.778s
36 |
37 | ```
38 |
39 | * We grep 'sap_type' because it appears in every SCTE-35 Cue, and only once, so we can count the number of cues detected.
40 | * 'sap_type' is proper var naming in python.
41 | ---
42 |
43 | ### Test 2: `threefive` with `PyPy 7.3.11`
44 |
45 | ``` smalltalk
46 | a@slow:~/cuei$ time threefivepypy3 ../v2.ts 2>&1 | grep sap_type | wc -l
47 | 14862
48 |
49 | real 0m3.543s
50 | user 0m2.880s
51 | sys 0m0.846s
52 | ```
53 | * We grep 'sap_type' because it appears in every SCTE-35 Cue, and only once, so we can count the number of cues detected.
54 |
55 |
56 | ---
57 | ### Test 3: `tsduck 3.36-3528` written in `C++`
58 |
59 | ```smalltalk
60 | a@slow:~/cuei$ time tsp -I file ../v2.ts -P splicemonitor -a -O drop | grep "Command type:" | wc -l
61 | 14862
62 |
63 | real 0m1.435s
64 | user 0m2.006s
65 | sys 0m0.861s
66 | ```
67 | ---
68 | * We grep 'Command type' because tsduck is not up to date with the specification and doesn't have sap type yet. 'Command type' appears in every tsduck SCTE-35 Cue, and only once, so we can count the number of cues detected.
69 |
70 |
71 | ### Test 4: [`cuei v1.1.93 "Junior"`](https://github.com/futzu/cuei) written in `Go`
72 |
73 | ```smalltalk
74 | a@slow:~/cuei$ time ./cuei ../v2.ts | grep SapType | wc -l
75 | 14862
76 |
77 | real 0m1.048s
78 | user 0m0.605s
79 | sys 0m0.509s
80 |
81 |
82 | ```
83 | * The code used for the test.
84 | ```go
85 | package main // 1
86 |
87 | import ( // 2
88 | "os" // 3
89 | "github.com/futzu/cuei" // 4
90 | ) // 5
91 |
92 | func main(){ // 6
93 | arg := os.Args[1] // 7
94 | stream := cuei.NewStream() // 8
95 | stream.Decode(arg) // 9
96 | } // 10 lines
97 | ```
98 | * We grep 'SapType' because it appears in every SCTE-35 Cue, and only once, so we can count the nunmber of cues detected.
99 | * 'SapType' is proper Go var naming.
100 |
101 | ---
102 |
103 | # Results:
104 |
105 | | tool | Cues Detected| GB/second |
106 | |---------------------|--------------|---------------|
107 | | threefive w/ python3| 14862 | 0.5697674 |
108 | | threefive w/ pypy3 | 14862 | 1.3830087 |
109 | | tsduck | 14862 | 3.4146341 |
110 | | cuei | 14862 | __4.6755725__|
111 |
112 |
113 |
114 | # Winner: [`cuei v1.1.93 "Junior"`](https://github.com/futzu/cuei)
115 | parsing over 4.6 GigaBytes per second. I haven't even optimized cuei for speed yet, it will go even faster.
116 |
117 | ### ADDENDUM:
118 | threefive didn't win, but even at the slowest, it's parsing over 500 MegaBytes a second, high quality 4K video is about 11 MegaBytes a second.
119 |
120 |
--------------------------------------------------------------------------------
/threefive-ffmpeg.md:
--------------------------------------------------------------------------------
1 | ### Two Critical things to remember when using ffmpeg with SCTE-35.
2 | 1) `-copyts` you need to keep the timestamps if you're transcoding.
3 | 2) `-muxpreload 0 -muxdelay 0` needs to be used to keep iframes and SCTE-35 aligned.
4 |
5 | # threefive works very well with ffmpeg.
6 | * __ffmpeg changes the SCTE-35 (0x86) stream type to bin data (0x6)__
7 | * __threefive is the only SCTE35 tool that parses both SCTE-35 `(0x86)` and bin data `(0x6)` stream types__.
8 | * __the threefive cli tool can convert the stream_type back to `0x86` after ffmpeg changes it.
9 |
10 | ### Example 1
11 | ---
12 | * Transcode mpegts with a SCTE-35 stream and pipe it to threefive to parse SCTE-35
13 | * oldvid.ts looks like this:
14 | ```
15 | Program 1
16 | Stream #0:0[0x31]: Video: h264 (High) ([27][0][0][0] / 0x001B), yuv420p(tv, bt709, progressive),
17 | 1280x720 [SAR 1:1 DAR 16:9], Closed Captions, 59.94 fps, 59.94 tbr, 90k tbn
18 | Stream #0:1[0x32]: Audio: mp2 ([4][0][0][0] / 0x0004), 48000 Hz, stereo, s16p, 256 kb/s
19 | Stream #0:2[0x33]: Audio: mp2 ([4][0][0][0] / 0x0004), 48000 Hz, stereo, s16p, 256 kb/s
20 | Stream #0:3[0x34]: Audio: mp2 ([4][0][0][0] / 0x0004), 48000 Hz, stereo, s16p, 256 kb/s
21 | Stream #0:4[0x35]: Audio: mp2 ([4][0][0][0] / 0x0004), 48000 Hz, stereo, s16p, 256 kb/s
22 | Stream #0:5[0x36]: Data: scte_35
23 | ```
24 | * transcode
25 | * `-copyts`, keep timestamps
26 | * `-map` keep SCTE-35 stream
27 |
28 | ```sh
29 | ffmpeg -copyts -i oldvid.ts -vcodec libx265 -map 0 -muxpreload 0 -muxdelay 0 -y newvid.ts
30 | ```
31 |
32 | * newvid.ts looks like this
33 | ```
34 | Program 1
35 | Stream #0:0[0x100]: Video: hevc (Main) (HEVC / 0x43564548), yuv420p(tv, bt709), 1280x720
36 | [SAR 1:1 DAR 16:9], 59.94 fps, 59.94 tbr, 90k tbn
37 | Stream #0:1[0x101]: Audio: mp2 ([3][0][0][0] / 0x0003), 48000 Hz, stereo, fltp, 384 kb/s
38 | Stream #0:2[0x102]: Audio: mp2 ([3][0][0][0] / 0x0003), 48000 Hz, stereo, fltp, 384 kb/s
39 | Stream #0:3[0x103]: Audio: mp2 ([3][0][0][0] / 0x0003), 48000 Hz, stereo, fltp, 384 kb/s
40 | Stream #0:4[0x104]: Audio: mp2 ([3][0][0][0] / 0x0003), 48000 Hz, stereo, fltp, 384 kb/s
41 | Stream #0:5[0x105]: Data: bin_data ([6][0][0][0] / 0x0006)
42 | ```
43 | * You can parse it as is with the threefive cli tool
44 | ```js
45 | threefive newvid.ts
46 | ```
47 | * transcode with ffmpeg and pipe into threefive cli as is
48 | ```js
49 | ffmpeg -copyts -i oldvid.ts -vcodec libx265 -map 0 -muxpreload 0 -muxdelay 0 -f mpegts -| threefive
50 | ```
51 | * You can also change the stream type from `0x6` back to `0x86` with __threefive sixfix__ so other SCTE-35 parsers can read the SCTE-35.
52 | ```js
53 | threefive mpegts sixfix sixed.ts
54 | fixing these pids {258}
55 | Wrote: sixfixed-newvideo.ts
56 | ```
57 |
58 |
--------------------------------------------------------------------------------
/threefive/README.md:
--------------------------------------------------------------------------------
1 | ### [threefive](https://github.com/futzu/SCTE35-threefive/)
2 |
3 | * [base.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/base.py) `threefive.SCTE35Base` class is the __Super__ class for all Splice Commands and Descriptors.
4 | * [bitn.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/bitn.py) `threefive.BitBin` and `threefive.NBin` classes.
5 | * [commands.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/commands.py) All `Splice Command` classes.
6 | * [crc.py](https://github.com/futzu/scte35-threefive/blob/master/threefive/crc.py) `threefive.crc32` function.
7 | * [cue.py ](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/cue.py) `threefive.Cue` class.
8 | * [decode.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/decode.py) `threefive.decode` function.
9 | * [descriptors.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/descriptors.py) All `Splice Descriptor` classes.
10 | * [encode.py](https://github.com/futzu/threefive/blob/master/threefive/encode.py) `threefive.mk_splice_null`, `threefive.mk_splice_insert`, and `threefive.mk_time_signal` functions.
11 | * [hls.py](https://github.com/futzu/threefive/blob/master/threefive/hls.py) `HLS SCTE-35 Parser classes and cli()` function. Replaces showcues.
12 | * [packetdata.py](https://github.com/futzu/threefive/blob/master/threefive/packetdata.py) `threefive.PacketData` class.
13 | * [section.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/section.py) `threefive.SpliceInfoSection` class.
14 | * [segment.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/segment.py) `threefive.Segment` class.
15 | * [segmentation.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/segmentation.py) `lookup tables` for the `threefive.SegmentationDescriptor` class.
16 | * [showcues.py](https://github.com/futzu/threefive/blob/master/threefive/showcues.py) `showcues HLS SCTE-35 Parser classes and cli()` function. Deprecated in favor of hls.py.
17 |
18 | * [sixfix.py](https://github.com/futzu/threefive/blob/master/threefive/sixfix.py) `threefive.sixfix ` function.
19 | * [smoketest.py](https://github.com/futzu/threefive/blob/master/threefive/smoketest.py) `threefive.smoke` function.
20 |
21 | * [stream.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/stream.py) `threefive.Stream` class.
22 | * [streamtypes.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/streamtypes.py) `threefive.streamtypes.streamtype_map` is a dict of mpegts stream types.
23 |
24 | * [stuff.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/stuff.py) `print2` function.
25 | * [superkabuki.py](https://github.com/futzu/threefive/blob/master/threefive/superkabuki.py) `threefive.SuperKabuki` class.
26 |
27 | * [upids.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/upids.py) `Segmentation Upids` classes.
28 | * [version.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/version.py) `threefive.version`
29 | * [xml.py](https://github.com/futzu/SCTE35-threefive/blob/master/threefive/xml.py) `threefive.xml.Node` and, `threefive.xml.XmlParser` classes and several xml related functions.
30 |
31 |
32 |
--------------------------------------------------------------------------------
/threefive/__init__.py:
--------------------------------------------------------------------------------
1 | """
2 | threefive.__init__.py
3 | """
4 |
5 | from .stuff import print2
6 | from .cue import Cue
7 | from .decode import decode
8 | from .section import SpliceInfoSection
9 | from .segment import Segment
10 | from .smoketest import smoke
11 | from .stream import Stream
12 | from .version import version
13 |
14 | from .commands import (
15 | TimeSignal,
16 | SpliceInsert,
17 | SpliceNull,
18 | PrivateCommand,
19 | BandwidthReservation,
20 | )
21 |
22 | from .descriptors import (
23 | AvailDescriptor,
24 | DVBDASDescriptor,
25 | DtmfDescriptor,
26 | SegmentationDescriptor,
27 | SpliceDescriptor,
28 | TimeDescriptor,
29 | )
30 |
31 | from .encode import (
32 | mk_splice_null,
33 | mk_splice_insert,
34 | mk_time_signal,
35 | )
36 |
--------------------------------------------------------------------------------
/threefive/base.py:
--------------------------------------------------------------------------------
1 | """
2 | threefive.base contains
3 | the class SCTE35Base.
4 | """
5 |
6 | import json
7 | from .bitn import NBin
8 | from .stuff import print2
9 | from .xml import Node
10 |
11 |
12 | class SCTE35Base:
13 | """
14 | SCTE35Base is a base class for
15 | SpliceCommand and SpliceDescriptor classes
16 | """
17 |
18 | ROLLOVER = 8589934591
19 |
20 | def __repr__(self):
21 | return str(self.__dict__)
22 |
23 | @staticmethod
24 | def _chk_nbin(nbin):
25 | if not nbin:
26 | nbin = NBin()
27 | return nbin
28 |
29 | def _chk_var(self, var_type, nbin_method, var_name, bit_count):
30 | """
31 | _chk_var is used to check var values and types before encoding
32 | """
33 | var_value = self.__dict__[var_name]
34 | if var_value is None:
35 | err_mesg = f"\033[7m{var_name} is not set, it should be {bit_count} bit(s) and type {var_type}\033[27m"
36 | raise ValueError(err_mesg)
37 | if not isinstance(var_value, var_type):
38 | err_mesg = f' \033[7m{var_name} is "{var_value}", it should be type {var_type}\033[27m and {bit_count} bit(s),\n '
39 | raise ValueError(err_mesg)
40 | nbin_method(var_value, bit_count)
41 |
42 | @staticmethod
43 | def as_90k(int_time):
44 | """
45 | ticks to 90k timestamps
46 | """
47 | return round((int_time / 90000.0), 6)
48 |
49 | @staticmethod
50 | def as_ticks(float_time):
51 | """
52 | 90k timestamps to ticks
53 | """
54 | return int(round(float_time * 90000))
55 |
56 | @staticmethod
57 | def as_hms(secs_of_time):
58 | """
59 | as_hms converts timestamp to
60 | 00:00:00.000 format
61 | """
62 | hours, seconds = divmod(secs_of_time, 3600)
63 | mins, seconds = divmod(seconds, 60)
64 | seconds = round(seconds, 3)
65 | output = f"{int(hours):02}:{int(mins):02}:{seconds:02}"
66 | if len(output.split(".")[1]) < 2:
67 | output += "0"
68 | return output
69 |
70 | @staticmethod
71 | def fix_hex(hexed):
72 | """
73 | fix_hex adds padded zero if needed for byte conversion.
74 | """
75 | return (hexed.replace("0x", "0x0", 1), hexed)[len(hexed) % 2 == 0]
76 |
77 | def get(self):
78 | """
79 | Returns instance as a dict
80 | """
81 | return self.kv_clean()
82 |
83 | def get_json(self):
84 | """
85 | get_json returns the instance
86 | data as json.
87 | """
88 | return json.dumps(self.get(), indent=4)
89 |
90 | def json(self):
91 | """
92 | json returns self as kv_clean'ed json
93 | """
94 | return self.get_json()
95 |
96 | def show(self):
97 | """
98 | show prints self as json to stderr (2)
99 | """
100 | print2(self.get_json())
101 |
102 | def kv_clean(self):
103 | """
104 | kv_clean removes items from a dict if the value is None
105 | """
106 |
107 | def b2l(val):
108 | if isinstance(val, (SCTE35Base)):
109 | val.kv_clean()
110 | if isinstance(val, (list)):
111 | val = [b2l(v) for v in val]
112 | if isinstance(val, (dict)):
113 | val = {k: b2l(v) for k, v in val.items()}
114 | if isinstance(val, (bytes, bytearray)):
115 | val = list(val)
116 | return val
117 |
118 | return {k: b2l(v) for k, v in vars(self).items() if v is not None}
119 |
120 | def has(self, what):
121 | """
122 | has runs hasattr with self and what
123 | """
124 | if hasattr(self, what):
125 | if vars(self)[what]:
126 | return True
127 | return False
128 |
129 | def xml(self, ns="scte35"):
130 | """
131 | xml default xml method will return
132 | all attributes, which is expressly allowed
133 | for SCTE-35 xml.
134 | """
135 | xml_attrs = self.kv_clean()
136 | iam = type(self)
137 | iam = str(iam).split("'", 1)[1].split("'", 1)[0]
138 | this = Node(iam, attrs=xml_attrs, ns=ns)
139 | return this
140 |
141 | @staticmethod
142 | def idxsplit(stuff, sep):
143 | """
144 | idxsplit is like split but you keep
145 | the sep
146 | example:
147 | >>> idxsplit('123456789',4)
148 | >>>'456789'
149 |
150 | """
151 | if sep in stuff:
152 | return stuff[stuff.index(sep) :]
153 | return False
154 |
155 | def load(self, stuff):
156 | """
157 | load is used to load
158 | data from a dict or json string
159 | """
160 | if isinstance(stuff, str):
161 | stuff = json.loads(stuff)
162 | if isinstance(stuff, dict):
163 | prevars= vars(self)
164 | for k, v in stuff.items():
165 | if k in prevars:
166 | self.__dict__[k] = v
167 | #self.__dict__.update(stuff)
168 |
--------------------------------------------------------------------------------
/threefive/bitn.py:
--------------------------------------------------------------------------------
1 | """
2 | The bitn.BitBin and bitn.NBin classes
3 | """
4 |
5 | from .stuff import print2
6 |
7 |
8 | class BitBin:
9 | """
10 | bitn.Bitbin takes a byte string and
11 | converts it to a integer, a very large integer
12 | if needed. A 1500 bit integer is no problem.
13 | several methods are available for slicing off bits.
14 | """
15 |
16 | def __init__(self, bites):
17 | # self.bites = bites
18 | self.bitsize = self.idx = len(bites) << 3
19 | self.bits = int.from_bytes(bites, byteorder="big")
20 |
21 | def as_90k(self, num_bits):
22 | """
23 | Returns num_bits
24 | of bits as 90k time
25 | """
26 | ninetyk = self.as_int(num_bits) / 90000.0
27 | return round(ninetyk, 6)
28 |
29 | def as_int(self, num_bits):
30 | """
31 | Starting at self.idx of self.bits,
32 | slice off num_bits of bits.
33 | """
34 | if self.idx >= num_bits:
35 | self.idx -= num_bits
36 | return (self.bits >> (self.idx)) & ~(~0 << num_bits)
37 | return False
38 |
39 | def as_hex(self, num_bits):
40 | """
41 | Returns the hex value
42 | of num_bits of bits
43 | """
44 | hexed = hex(self.as_int(num_bits))
45 | return (hexed.replace("0x", "0x0", 1), hexed)[len(hexed) % 2 == 0]
46 |
47 | def as_charset(self, num_bits, charset="ascii"):
48 | """
49 | Returns num_bits of bits
50 | as bytes decoded as charset
51 | default charset is ascii.
52 | """
53 | # print(charset)
54 | stuff = self.as_int(num_bits)
55 | wide = num_bits >> 3
56 | if charset is None:
57 | return int.to_bytes(stuff, wide, byteorder="big")
58 | return int.to_bytes(stuff, wide, byteorder="big").decode(
59 | charset, errors="replace"
60 | )
61 |
62 | def as_bytes(self, num_bits):
63 | """
64 | Returns num_bits of bits
65 | as bytes
66 | """
67 | stuff = self.as_int(num_bits)
68 | wide = num_bits >> 3
69 | return int.to_bytes(stuff, wide, byteorder="big")
70 |
71 | def as_flag(self, num_bits=1):
72 | """
73 | Returns one bit as True or False
74 | """
75 | return self.as_int(num_bits) & 1 == 1
76 |
77 | def forward(self, num_bits):
78 | """
79 | Advances the start point
80 | forward by num_bits
81 | """
82 | self.idx -= num_bits
83 |
84 | def negative_shift(self, num_bits):
85 | """
86 | negative_shift is called instead of
87 | throwing a negative shift count error.
88 | """
89 | print2(f"{num_bits} bits requested, but only {self.idx} bits left.")
90 | print2(f"\n bytes remaining: {self.as_bytes(self.idx)} ")
91 |
92 |
93 | class NBin:
94 | """
95 | bitn.NBin is
96 | the reverse BitBin.
97 | Encodes data to integers
98 | and then bytes
99 | """
100 |
101 | def __init__(self):
102 | self.nbits = 0
103 | self.idx = 0
104 | self.bites = b""
105 |
106 | def nbits2bites(self):
107 | """
108 | nbits2bites converts
109 | the int self.nbits to bytes as self.bites
110 | and sets self.nbits and self.idx to 0
111 | """
112 | bites_wide = self.idx >> 3
113 | self.bites += int.to_bytes(self.nbits, bites_wide, byteorder="big")
114 | self.nbits = 0
115 | self.idx = 0
116 |
117 | def add_bites(self, plus_bites):
118 | """
119 | add_bites appends plus_bites
120 | to self.bites
121 | """
122 | if isinstance(plus_bites, int):
123 | plus_bites = bytes.fromhex(hex(plus_bites)[2:])
124 | self.bites += plus_bites
125 |
126 | # if self.idx % 8 == 0:
127 | # self.nbits2bites()
128 |
129 | def add_int(self, int_bits, bit_len):
130 | """
131 | left shift nbits and append new_bits
132 | """
133 | self.idx += bit_len
134 | self.nbits = (self.nbits << bit_len) | int_bits
135 | if self.idx % 8 == 0:
136 | self.nbits2bites()
137 |
138 | def add_90k(self, pts, bit_len=33):
139 | """
140 | Converts 90k float timestamps
141 | to an int and appends it to nbits
142 | via self.add_int
143 | """
144 | ninetyk = int(pts * 90000.0)
145 | self.add_int(ninetyk, bit_len)
146 |
147 | def add_hex(self, hex_str, bit_len):
148 | """
149 | add_hex converts a
150 | hex encoded string to an int
151 | and appends it to self.nbits
152 | via self.add_int
153 | """
154 | if isinstance(hex_str, str):
155 | dehexed = int(hex_str, 16)
156 | # just in case hex_str is an int....
157 | else:
158 | dehexed = hex_str
159 | self.add_int(dehexed, bit_len)
160 |
161 | def add_flag(self, flg, bit_len=1):
162 | """
163 | add_flag takes a boolean
164 | value and adds it as an integer
165 | to self.nbits via self.add_int
166 | """
167 | bit_len = 1
168 | self.add_int(flg.real, bit_len)
169 |
170 | def reserve(self, num):
171 | """
172 | reserve sets 'num' bits to 1
173 | and appends them to self.nbits
174 | via self.add_int
175 | """
176 | bit_len = 1
177 | while num:
178 | self.add_int(1, bit_len)
179 | num -= 1
180 |
181 | def forward(self, num):
182 | """
183 | Currently just an alias to reserve
184 | """
185 | self.reserve(num)
186 |
187 | def zeroed(self, num):
188 | """
189 | zeroed sets num bits to zero
190 | """
191 | bit_len = 1
192 | while num:
193 | self.add_int(0, bit_len)
194 |
--------------------------------------------------------------------------------
/threefive/crc.py:
--------------------------------------------------------------------------------
1 | """
2 | crc.py crc32 function for encoding.
3 | """
4 |
5 | POLY = 0x104C11DB7
6 | INIT_VALUE = 0xFFFFFFFF
7 | ZERO = 0x0
8 | ONE = 0x1
9 | EIGHT = 0x8
10 | TWENTY_FOUR = 0x18
11 | THIRTY_TWO = 0x20
12 | TWO_FIFTY_FIVE = 0xFF
13 | TWO_FIFTY_SIX = 0x100
14 |
15 |
16 | def _bytecrc(crc, poly):
17 | mask = ONE << (THIRTY_TWO - ONE)
18 | i = EIGHT
19 | while i:
20 | crc = (crc << ONE, crc << ONE ^ poly)[crc & mask != ZERO]
21 | i -= ONE
22 | return crc & INIT_VALUE
23 |
24 |
25 | def _mk_table():
26 | mask = (ONE << THIRTY_TWO) - ONE
27 | poly = POLY & mask
28 | return [_bytecrc((i << TWENTY_FOUR), poly) for i in range(TWO_FIFTY_SIX)]
29 |
30 |
31 | def crc32(data):
32 | """
33 | generate a 32 bit crc
34 | """
35 |
36 | table = _mk_table()
37 | crc = INIT_VALUE
38 | for bite in data:
39 | crc = table[bite ^ ((crc >> TWENTY_FOUR) & TWO_FIFTY_FIVE)] ^ (
40 | (crc << EIGHT) & (INIT_VALUE - TWO_FIFTY_FIVE)
41 | )
42 | return crc
43 |
44 |
45 | def crc32hex(data):
46 | """
47 | crc32hex crc32 returned as hex
48 | """
49 | return hex(crc32(data))
50 |
--------------------------------------------------------------------------------
/threefive/decode.py:
--------------------------------------------------------------------------------
1 | """
2 | decode.py
3 |
4 | decode is a SCTE-35 decoder function
5 | with input type auto-detection.
6 |
7 | SCTE-35 data can be parsed with just
8 | one function call.
9 |
10 | the arg stuff is the input.
11 | if stuff is not set, decode will attempt
12 | to read mpegts video from sys.stdin.buffer.
13 |
14 | SCTE-35 data is printed in JSON format.
15 |
16 | For more parsing and output control,
17 | see the Cue and Stream classes.
18 |
19 | """
20 |
21 | import sys
22 |
23 | from .cue import Cue
24 | from .stream import Stream
25 |
26 |
27 | def _read_stuff(stuff):
28 | try:
29 | # Mpegts Video
30 | strm = Stream(stuff)
31 | strm.decode()
32 | return True
33 | except:
34 | try:
35 | cue = Cue(stuff)
36 | cue.decode()
37 | cue.show()
38 | return True
39 | except:
40 | return False
41 |
42 |
43 | def decode(stuff=None):
44 | """
45 | decode is a SCTE-35 decoder function
46 | with input type auto-detection.
47 |
48 | SCTE-35 data is printed in JSON format.
49 |
50 | Use like:
51 |
52 | # Base64
53 | stuff = '/DAvAAAAAAAA///wBQb+dGKQoAAZAhdDVUVJSAAAjn+fCAgAAAAALKChijUCAKnMZ1g='
54 | threefive.decode(stuff)
55 |
56 | # Bytes
57 | payload = b"\xfc0\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\x00\x00\x00O%3\x96"
58 | threefive.decode(payload)
59 |
60 | # Hex String
61 | stuff = '0XFC301100000000000000FFFFFF0000004F253396'
62 | threefive.decode(stuff)
63 |
64 | # Hex Literal
65 | threefive.decode(0XFC301100000000000000FFFFFF0000004F253396)
66 |
67 | # Integer
68 | big_int = 1439737590925997869941740173214217318917816529814
69 | threefive.decode(big_int)
70 |
71 | # Mpegts File
72 | threefive.decode('/path/to/mpegts')
73 |
74 | # Mpegts HTTP/HTTPS Streams
75 | threefive.decode('https://futzu.com/xaa.ts')
76 |
77 | """
78 | if stuff in [None, sys.stdin.buffer]:
79 | # Mpegts stream or file piped in
80 | return Stream(sys.stdin.buffer).decode()
81 | if isinstance(stuff, int):
82 | return _read_stuff(hex(stuff))
83 | return _read_stuff(stuff)
84 |
--------------------------------------------------------------------------------
/threefive/encode.py:
--------------------------------------------------------------------------------
1 | """
2 | encode.py
3 |
4 | threefive.encode has helper functions for Cue encoding.
5 |
6 | """
7 |
8 | from .commands import SpliceNull, SpliceInsert, TimeSignal
9 | from .cue import Cue
10 |
11 |
12 | def mk_splice_null():
13 | """
14 | mk_splice_null returns a Cue
15 | with a Splice Null
16 | """
17 | cue = Cue()
18 | sn = SpliceNull()
19 | cue.command = sn
20 | cue.encode()
21 | return cue
22 |
23 |
24 | def mk_time_signal(pts=None):
25 | """
26 | mk_time_signal returns a Cue
27 | with a Time Signal
28 |
29 | if pts is None:
30 | time_specified_flag False
31 |
32 | if pts IS set:
33 | time_specified_flag True
34 | pts_time pts
35 |
36 | """
37 | cue = Cue()
38 | ts = TimeSignal()
39 | ts.time_specified_flag = False
40 | if pts:
41 | pts = float(pts)
42 | ts.time_specified_flag = True
43 | ts.pts_time = pts
44 | cue.command = ts
45 | cue.encode()
46 | return cue
47 |
48 |
49 | def mk_splice_insert(event_id, pts=None, duration=None, out=False):
50 | """
51 | mk_splice_insert returns a Cue with a Splice Insert.
52 |
53 | The args set the SpliceInsert vars.
54 |
55 | splice_event_id = event_id
56 |
57 | if pts is None (default):
58 | splice_immediate_flag True
59 | time_specified_flag False
60 |
61 | if pts:
62 | splice_immediate_flag False
63 | time_specified_flag True
64 | pts_time pts
65 |
66 | If duration is None (default)
67 | duration_flag False
68 |
69 | if duration IS set:
70 | out_of_network_indicator True
71 | duration_flag True
72 | break_auto_return True
73 | break_duration duration
74 | pts_time pts
75 |
76 | if out is True:
77 | out_of_network_indicator True
78 |
79 | if out is False (default):
80 | out_of_network_indicator False
81 |
82 | """
83 | cue = Cue()
84 | # default is a CUE-IN
85 | sin = SpliceInsert()
86 | sin.splice_event_id = event_id
87 | sin.splice_event_cancel_indicator = False
88 | sin.out_of_network_indicator = out
89 | sin.duration_flag = False
90 | sin.unique_program_id = event_id
91 | sin.avail_num = 0
92 | sin.avails_expected = 0
93 | sin.splice_immediate_flag = True
94 | sin.time_specified_flag = False
95 | sin.program_splice_flag = True
96 | sin.event_id_compliance_flag = True
97 | # pts = None for Splice Immediate
98 | if pts:
99 | sin.splice_immediate_flag = False
100 | sin.time_specified_flag = True
101 | sin.pts_time = float(pts)
102 | else:
103 | sin.component_count = 0
104 | # If we have a duration, set duration
105 | if duration:
106 | duration = float(duration)
107 | sin.break_duration = duration
108 | sin.break_auto_return = True
109 | sin.duration_flag = True
110 | sin.out_of_network_indicator = True
111 | # Add SpliceInsert to the SCTE35 cue
112 | cue.command = sin
113 | cue.encode()
114 | return cue
115 |
--------------------------------------------------------------------------------
/threefive/packetdata.py:
--------------------------------------------------------------------------------
1 | """
2 | packetdata.py
3 | """
4 |
5 | from .base import SCTE35Base
6 |
7 |
8 | class PacketData(SCTE35Base):
9 | """
10 | A PacketData instance is used
11 | to hold packet pid, program, pcr and pts
12 | for SCTE-35 packets.
13 | """
14 |
15 | def __init__(self, pid, prgm):
16 | self.pid = hex(pid)
17 | self.program = prgm
18 | self.pcr = None
19 | self.pts = None
20 |
21 | def mk_pcr(self, table):
22 | """
23 | calculates and formats pcr
24 | """
25 | try:
26 | pcr_ticks = table[self.program]
27 | self.pcr = self.as_90k(pcr_ticks)
28 | except:
29 | pass
30 |
31 | def mk_pts(self, table):
32 | """
33 | mk_pts calculates and formats pts
34 | """
35 | try:
36 | pts_ticks = table[self.program]
37 | self.pts = self.as_90k(pts_ticks)
38 | except:
39 | pass
40 |
--------------------------------------------------------------------------------
/threefive/section.py:
--------------------------------------------------------------------------------
1 | """
2 | section.py
3 |
4 | SCTE35 Splice Info Section
5 | """
6 |
7 | from .bitn import BitBin
8 | from .base import SCTE35Base
9 | from .xml import Node
10 |
11 |
12 | sap_map = {
13 | "0x00": "Type 1 Closed GOP with no leading pictures",
14 | "0x01": "Type 2 Closed GOP with leading pictures",
15 | "0x02": "Type 3 Open GOP",
16 | "0x03": "No Sap Type",
17 | }
18 |
19 |
20 | class SpliceInfoSection(SCTE35Base):
21 | """
22 | The SCTE-35 splice info section
23 | data.
24 | """
25 |
26 | def __init__(self):
27 | self.table_id = None
28 | self.section_syntax_indicator = None
29 | self.private = None
30 | # sap_type used to be marked reserved.
31 | self.sap_type = None
32 | self.sap_details = None
33 | self.section_length = None
34 | self.protocol_version = None
35 | self.encrypted_packet = None
36 | self.encryption_algorithm = None
37 | self.pts_adjustment = 0
38 | self.cw_index = None
39 | self.tier = None
40 | self.splice_command_length = None
41 | self.splice_command_type = None
42 | self.descriptor_loop_length = 0
43 | self.crc = None
44 |
45 | def decode(self, bites):
46 | """
47 | InfoSection.decode
48 | """
49 | bitbin = BitBin(bites)
50 | self.table_id = bitbin.as_hex(8)
51 | if self.table_id != "0xfc":
52 | raise ValueError(
53 | ("splice_info_section.table_id should be 0xfc Not: ", self.table_id)
54 | )
55 | self.section_syntax_indicator = bitbin.as_flag(1)
56 | self.private = bitbin.as_flag(1)
57 | self.sap_type = bitbin.as_hex(2)
58 | self.sap_details = sap_map[self.sap_type]
59 | self.section_length = bitbin.as_int(12)
60 | self.protocol_version = bitbin.as_int(8)
61 | self.encrypted_packet = bitbin.as_flag(1)
62 | self.encryption_algorithm = bitbin.as_int(6)
63 | pts_adjustment_ticks = bitbin.as_int(33)
64 | self.pts_adjustment = self.as_90k(pts_adjustment_ticks)
65 | self.cw_index = bitbin.as_hex(8)
66 | self.tier = bitbin.as_hex(12)
67 | self.splice_command_length = bitbin.as_int(12)
68 | self.splice_command_type = bitbin.as_int(8)
69 |
70 | def _encode_table_id(self, nbin):
71 | """
72 | encode SpliceInfoSection.table_id
73 | """
74 | self.table_id = "0xfc"
75 | nbin.add_hex(self.table_id, 8)
76 |
77 | def _encode_section_syntax_indicator(self, nbin):
78 | """
79 | encode SpliceInfoSection.section_syntax_indicator
80 | """
81 | self.section_syntax_indicator = False
82 | nbin.add_flag(self.section_syntax_indicator, 1)
83 |
84 | def _encode_private_flag(self, nbin):
85 | """
86 | encode SpliceInfoSection.private
87 | """
88 | self.private = False
89 | nbin.add_flag(self.private, 1)
90 |
91 | def _encode_sap(self, nbin):
92 | """
93 | the 3 reserved bits now map SAP
94 | """
95 | if self.sap_type not in sap_map:
96 | self.sap_type = "0x03"
97 | self.sap_details = sap_map[self.sap_type]
98 | nbin.add_hex(self.sap_type, 2)
99 |
100 | def _encode_section_length(self, nbin):
101 | """
102 | encode SpliceInfoSection.section_length
103 | """
104 | if not self.section_length:
105 | self.section_length = 11
106 | nbin.add_int(self.section_length, 12)
107 |
108 | def _encode_protocol_version(self, nbin):
109 | """
110 | encode SpliceInfoSection.protocol_version
111 | """
112 | if not self.protocol_version:
113 | self.protocol_version = 0
114 | nbin.add_int(self.protocol_version, 8)
115 |
116 | def _encode_encrypted(self, nbin):
117 | """
118 | encode SpliceInfoSection.encrypted_packet
119 | and SpliceInfoSection.encyption_algorithm
120 | """
121 | if not self.encrypted_packet:
122 | self.encrypted_packet = False
123 | nbin.add_flag(self.encrypted_packet)
124 | if not self.encryption_algorithm:
125 | self.encryption_algorithm = 0
126 | nbin.add_int(self.encryption_algorithm, 6)
127 |
128 | def _encode_pts_adjustment(self, nbin):
129 | """
130 | encode SpliceInfoSection.pts_adjustment_ticks
131 | """
132 | nbin.add_int(self.as_ticks(self.pts_adjustment), 33)
133 |
134 | def _encode_cw_index(self, nbin):
135 | """
136 | encode SpliceInfoSection.cw_index
137 | """
138 | if not self.cw_index:
139 | self.cw_index = "0x0"
140 | nbin.add_hex(self.cw_index, 8)
141 |
142 | def _encode_tier(self, nbin):
143 | """
144 | encode SpliceInfoSection.tier
145 | """
146 | if not self.tier:
147 | self.tier = "0xfff"
148 | nbin.add_hex(self.tier, 12)
149 |
150 | def _encode_splice_command(self, nbin):
151 | """
152 | encode Splice.InfoSection.splice_command_length
153 | and Splice.InfoSection.splice_command_type
154 | """
155 | if not self.splice_command_length:
156 | self.splice_command_length = 0
157 | nbin.add_int(self.splice_command_length, 12)
158 | if not self.splice_command_type:
159 | self.splice_command_type = 0
160 | nbin.add_int(self.splice_command_type, 8)
161 |
162 | def encode(self, nbin=None):
163 | """
164 | SpliceInfoSection.encode
165 | takes the vars from an instance and
166 | encodes them as bytes.
167 | """
168 | nbin = self._chk_nbin(nbin)
169 | self._encode_table_id(nbin)
170 | self._encode_section_syntax_indicator(nbin)
171 | self._encode_private_flag(nbin)
172 | self._encode_sap(nbin)
173 | self._encode_section_length(nbin)
174 | self._encode_protocol_version(nbin)
175 | self._encode_encrypted(nbin)
176 | self._encode_pts_adjustment(nbin)
177 | self._encode_cw_index(nbin)
178 | self._encode_tier(nbin)
179 | self._encode_splice_command(nbin)
180 | return nbin.bites
181 |
182 | def xml(self, ns="scte35"):
183 | """
184 | xml create xml node for splice info section
185 | """
186 | sis_attrs = {
187 | "xmlns": "https://scte.org/schemas/35",
188 | "pts_adjustment": self.as_ticks(self.pts_adjustment),
189 | "protocol_version": self.protocol_version,
190 | "sap_type": self.sap_type,
191 | "tier": self.tier,
192 | }
193 | sis = Node("SpliceInfoSection", attrs=sis_attrs, ns=ns)
194 | return sis
195 |
196 | def from_xml(self, stuff):
197 | """
198 | from_xml SpliceInfoSection from Xml
199 | """
200 | short = stuff["SpliceInfoSection"]
201 | self.load(short)
202 |
--------------------------------------------------------------------------------
/threefive/segment.py:
--------------------------------------------------------------------------------
1 | """
2 | The threefive.Segment class
3 | """
4 |
5 | import os
6 | from new_reader import reader
7 | from .stream import Stream
8 |
9 | AES = True
10 | try:
11 | import pyaes
12 | except:
13 | AES = False
14 |
15 |
16 | class Segment(Stream):
17 | """
18 | The Segment class is a Sub Class of threefive.Stream
19 | made for small, fixed size MPEGTS files,like HLS segments.
20 |
21 | Segment Class Specific Features:
22 |
23 | * Decryption of AES Encrypted MPEGTS.
24 |
25 | * Segment.cues a list of SCTE35 cues found in the segment.
26 |
27 |
28 | Example:
29 |
30 | from threefive import Segment
31 |
32 | >>>> uri = "https://example.com/1.ts"
33 | >>>> seg = Segment(uri)
34 | >>>> seg.decode()
35 | >>>> [cue.encode() for cue in seg.cues]
36 | ['/DARAAAAAAAAAP/wAAAAAHpPv/8=',
37 | '/DAvAAAAAAAAAP/wFAUAAAKWf+//4WoauH4BTFYgAAEAAAAKAAhDVUVJAAAAAOv1oqc=']
38 |
39 |
40 | AES Encryption Example:
41 |
42 | from threefive import Segment
43 |
44 | >>>> key = "https://example.com/aes.key"
45 | >>>> IV=0x998C575D24F514AEC84EDC5CABCCDB81
46 | >>>> uri = "https://example.com/aes-1.ts"
47 |
48 | >>>> seg = Segment(uri,key_uri=key, iv=IV)
49 | >>>> seg.decode()
50 | >>>> {cue.packet_data.pts:cue.encode() for cue in seg.cues}
51 |
52 | { 89718.451333: '/DARAAAAAAAAAP/wAAAAAHpPv/8=',
53 | 89730.281789: '/DAvAAAAAAAAAP/wFAUAAAKWf+//4WoauH4BTFYgAAEAAAAKAAhDVUVJAAAAAOv1oqc='}
54 |
55 | """
56 |
57 | def __init__(self, seg_uri, key_uri=None, iv=None):
58 | self.seg_uri = seg_uri
59 | self.key_uri = key_uri
60 | self.key = None
61 | self.iv = None
62 | self.cues = []
63 | self.pts_start = None
64 | self.pts_last = None
65 | self.shush = False
66 | self.tmp = None
67 | self.duration = None
68 | if AES:
69 | if iv:
70 | iv = iv.replace("\n", "")
71 | self.iv = int.to_bytes(int(iv, base=16), 16, byteorder="big")
72 | if self.key_uri:
73 | self._aes_get_key()
74 | self._aes_decrypt()
75 | super().__init__(self.seg_uri)
76 |
77 | def __repr__(self):
78 | return str(self.__dict__)
79 |
80 | def _mk_tmp(self):
81 | self.tmp = "tf-"
82 | self.tmp += self.seg_uri.rsplit("/", 1)[-1]
83 |
84 | def _aes_get_key(self):
85 | with reader(self.key_uri) as quay:
86 | self.key = quay.read()
87 |
88 | def _aes_decrypt(self):
89 | mode = pyaes.AESModeOfOperationCBC(self.key, iv=self.iv)
90 | self._mk_tmp()
91 | with open(self.tmp, "wb") as outfile, reader(self.seg_uri) as infile:
92 | pyaes.decrypt_stream(mode, infile, outfile)
93 | self.seg_uri = self.tmp
94 |
95 | def _add_cue(self, cue):
96 | """
97 | _add_cue is called by a segment instance
98 | to collect SCTE35 cues.
99 | """
100 | self.cues.append(cue)
101 |
102 | def shushed(self):
103 | """
104 | shushed sets self.shush to true to suppress
105 | printing SCTE-35 Cue data.
106 | """
107 | self.shush = True
108 |
109 | def show_cue(self, cue):
110 | """
111 | show_cue prints SCTE35 Cue data
112 | and calls add_cue to append the cue to
113 | the Segment,cues list.
114 | """
115 | if not self.shush:
116 | cue.show()
117 | self._add_cue(cue)
118 |
119 | def decode(self, func=None):
120 | """
121 | decode a mpegts segment.
122 | """
123 |
124 | super().decode_fu(func=self.show_cue)
125 | try:
126 | self.pts_start = self.as_90k(self.start.popitem()[1])
127 | except:
128 | pass
129 | try:
130 | self.pts_last = self.as_90k(list(self.maps.prgm_pts.items())[0][1])
131 | except:
132 | pass
133 | if self.tmp:
134 | os.unlink(self.tmp)
135 | if self.pts_start and self.pts_last:
136 | self.duration = round(self.pts_last - self.pts_start, 6)
137 |
--------------------------------------------------------------------------------
/threefive/segmentation.py:
--------------------------------------------------------------------------------
1 | """
2 | segmentation.py
3 |
4 | SCTE35 Segmentation Descriptor tables.
5 | """
6 |
7 | table20 = {
8 | 0x00: "Restrict Group 0",
9 | 0x01: "Restrict Group 1",
10 | 0x02: "Restrict Group 2",
11 | 0x03: "No Restrictions",
12 | }
13 |
14 |
15 | table22 = {
16 | 0x00: "Not Indicated",
17 | 0x01: "Content Identification",
18 | 0x02: "Call Ad Server", # Addressable tv stuff
19 | 0x10: "Program Start",
20 | 0x11: "Program End",
21 | 0x12: "Program Early Termination",
22 | 0x13: "Program Breakaway",
23 | 0x14: "Program Resumption",
24 | 0x15: "Program Runover Planned",
25 | 0x16: "Program RunoverUnplanned",
26 | 0x17: "Program Overlap Start",
27 | 0x18: "Program Blackout Override",
28 | 0x19: "Program Start ??? In Progress",
29 | 0x20: "Chapter Start",
30 | 0x21: "Chapter End",
31 | 0x22: "Break Start",
32 | 0x23: "Break End",
33 | 0x30: "Provider Advertisement Start",
34 | 0x31: "Provider Advertisement End",
35 | 0x32: "Distributor Advertisement Start",
36 | 0x33: "Distributor Advertisement End",
37 | 0x34: "Provider Placement Opportunity Start",
38 | 0x35: "Provider Placement Opportunity End",
39 | 0x36: "Distributor Placement Opportunity Start",
40 | 0x37: "Distributor Placement Opportunity End",
41 | 0x38: "Provider Overlay Placement Opportunity Start",
42 | 0x39: "Provider Overlay Placement Opportunity End",
43 | 0x3A: "Distributor Overlay Placement Opportunity Start",
44 | 0x3B: "Distributor Overlay Placement Opportunity End",
45 | 0x3C: "Provider Promo Start",
46 | 0x3D: "Provider Promo End",
47 | 0x3E: "Distributor Promo Start",
48 | 0x3F: "Distributor Promo End",
49 | 0x40: "Unscheduled Event Start",
50 | 0x41: "Unscheduled Event End",
51 | 0x42: "Alternate Content Opportunity Start",
52 | 0x43: "Alternate Content Opportunity End",
53 | 0x44: "Provider Ad Block Start",
54 | 0x45: "Provider Ad Block End",
55 | 0x46: "Distributor Ad Block Start",
56 | 0x47: "Distributor Ad Block End",
57 | 0x50: "Network Start",
58 | 0x51: "Network End",
59 | }
60 |
61 |
62 | """
63 | DVB Equivalent Segmentation Type
64 | """
65 | dvb_table2 = {
66 | 0x0: "No Equivalent",
67 | 0x1: "Distributor Placement Opportunity",
68 | 0x2: "Provider Placement Opportunity",
69 | 0x3: "Distributor Advertisement",
70 | 0x4: "Provider Advertisement",
71 | }
72 |
--------------------------------------------------------------------------------
/threefive/sixfix.py:
--------------------------------------------------------------------------------
1 | """
2 | sixfix.py
3 | """
4 |
5 | import io
6 | import sys
7 | from threefive.crc import crc32
8 | from threefive.bitn import NBin
9 | from threefive.stuff import print2
10 | from threefive.stream import Stream
11 |
12 |
13 | def passed(cue):
14 | """
15 | passed a no-op function
16 | """
17 | return cue
18 |
19 |
20 | class PreFix(Stream):
21 | """
22 | PreFix is used to gather 06 Bin data pids with SCTE-35.
23 | """
24 |
25 | def decode(self, func=passed):
26 | super().decode(func=passed)
27 | sixed = self.pids.maybe_scte35
28 | if sixed:
29 | print("fixing these pids", sixed)
30 | return sixed
31 |
32 |
33 | class SixFix(Stream):
34 | """
35 | SixFix class
36 | fixes bin data streams with SCTE-35 to 0x86 SCTE-35 streams
37 | """
38 |
39 | CUEI_DESCRIPTOR = b"\x05\x04CUEI"
40 |
41 | def __init__(self, tsdata=None):
42 | super().__init__(tsdata)
43 | self.pmt_payload = None
44 | self.con_pids = set()
45 | self.out_file = "sixfixed-" + tsdata.rsplit("/")[-1]
46 | self.in_file = sys.stdin.buffer
47 |
48 | def _parse_by_pid(self, pkt, pid):
49 | if pid in self.pids.tables:
50 | self._parse_tables(pkt, pid)
51 | if pid in self.pids.pmt:
52 | if self.pmt_payload:
53 | pkt = pkt[:4] + self.pmt_payload
54 | return pkt
55 |
56 | def convert_pids(self):
57 | """
58 | convert_pids
59 | changes the stream type to 0x86 and replaces
60 | the existing PMT as it writes packets to the outfile
61 | """
62 | active = io.BytesIO()
63 | pkt_count = 0
64 | chunk_size = 2048
65 | if isinstance(self.out_file, str):
66 | self.out_file = open(self.out_file, "wb")
67 | with self.out_file as out_file:
68 | for pkt in self.iter_pkts():
69 | pid = self._parse_pid(pkt[1], pkt[2])
70 | pkt = self._parse_by_pid(pkt, pid)
71 | active.write(pkt)
72 | pkt_count = (pkt_count + 1) % chunk_size
73 | if not pkt_count:
74 | out_file.write(active.getbuffer())
75 | active = io.BytesIO()
76 |
77 | def _regen_pmt(self, n_seclen, pcr_pid, n_proginfolen, n_info_bites, n_streams):
78 | nbin = NBin()
79 | nbin.add_int(2, 8) # 0x02
80 | nbin.add_int(1, 1) # section Syntax indicator
81 | nbin.add_int(0, 1) # 0
82 | nbin.add_int(3, 2) # reserved
83 | nbin.add_int(n_seclen, 12) # section length
84 | nbin.add_int(1, 16) # program number
85 | nbin.add_int(3, 2) # reserved
86 | nbin.add_int(0, 5) # version
87 | nbin.add_int(1, 1) # current_next_indicator
88 | nbin.add_int(0, 8) # section number
89 | nbin.add_int(0, 8) # last section number
90 | nbin.add_int(7, 3) # res
91 | nbin.add_int(pcr_pid, 13)
92 | nbin.add_int(15, 4) # res
93 | nbin.add_int(n_proginfolen, 12)
94 | nbin.add_bites(n_info_bites)
95 | nbin.add_bites(n_streams)
96 | a_crc = crc32(nbin.bites)
97 | nbin.add_int(a_crc, 32)
98 | n_payload = nbin.bites
99 | pad = 187 - (len(n_payload) + 4)
100 | pointer_field = b"\x00"
101 | if pad > 0:
102 | n_payload = pointer_field + n_payload + (b"\xff" * pad)
103 | self.pmt_payload = n_payload
104 |
105 | def _parse_pmt(self, pay, pid):
106 | """
107 | parse program maps for streams
108 | """
109 | pay = self._chk_partial(pay, pid, self._PMT_TID)
110 | if not pay:
111 | return False
112 | seclen = self._parse_length(pay[1], pay[2])
113 | n_seclen = seclen + 6
114 | if self._section_incomplete(pay, pid, seclen):
115 | return False
116 | program_number = self._parse_program(pay[3], pay[4])
117 | pcr_pid = self._parse_pid(pay[8], pay[9])
118 | self.pids.pcr.add(pcr_pid)
119 | self.maps.pid_prgm[pcr_pid] = program_number
120 | proginfolen = self._parse_length(pay[10], pay[11])
121 | idx = 12
122 | n_proginfolen = proginfolen + len(self.CUEI_DESCRIPTOR)
123 | end = idx + proginfolen
124 | info_bites = pay[idx:end]
125 | n_info_bites = info_bites + self.CUEI_DESCRIPTOR
126 | while idx < end:
127 | # d_type = pay[idx]
128 | idx += 1
129 | d_len = pay[idx]
130 | idx += 1
131 | # d_bytes = pay[idx - 2 : idx + d_len]
132 | idx += d_len
133 | si_len = seclen - 9
134 | si_len -= proginfolen
135 | n_streams = self._parse_program_streams(si_len, pay, idx, program_number)
136 | self._regen_pmt(n_seclen, pcr_pid, n_proginfolen, n_info_bites, n_streams)
137 | return True
138 |
139 | def _parse_program_streams(self, si_len, pay, idx, program_number):
140 | """
141 | parse the elementary streams
142 | from a program
143 | """
144 | chunk_size = 5
145 | end_idx = (idx + si_len) - 4
146 | start = idx
147 | while idx < end_idx:
148 | pay, stream_type, pid, ei_len = self._parse_stream_type(pay, idx)
149 | idx += chunk_size
150 | idx += ei_len
151 | self.maps.pid_prgm[pid] = program_number
152 | self._set_scte35_pids(pid, stream_type)
153 | streams = pay[start:end_idx]
154 | return streams
155 |
156 | def _parse_stream_type(self, pay, idx):
157 | """
158 | extract stream pid and type
159 | """
160 | npay = pay
161 | stream_type = pay[idx]
162 | el_pid = self._parse_pid(pay[idx + 1], pay[idx + 2])
163 | if el_pid in self.con_pids:
164 | if stream_type == 6:
165 | npay = pay[:idx] + b"\x86" + pay[idx + 1 :]
166 | ei_len = self._parse_length(pay[idx + 3], pay[idx + 4])
167 | return npay, stream_type, el_pid, ei_len
168 |
169 |
170 | def sixfix(arg):
171 | """
172 | sixfix converts 0x6 bin data mpegts streams
173 | that contain SCTE-35 data to stream type 0x86
174 | """
175 | s1 = PreFix(arg)
176 | sixed = s1.decode(func=passed)
177 | if not sixed:
178 | print2("No bin data SCTE-35 streams were found.")
179 | else:
180 | s2 = SixFix(arg)
181 | s2.con_pids = sixed
182 | s2.convert_pids()
183 | print2(f'Wrote: sixfixed-{arg.rsplit("/")[-1]}')
184 |
185 |
186 | if __name__ == "__main__":
187 | sixfix(sys.argv[1])
188 |
--------------------------------------------------------------------------------
/threefive/smoketest.py:
--------------------------------------------------------------------------------
1 | """
2 | smoke_test.py
3 | """
4 |
5 | from .decode import decode
6 | from .stuff import print2
7 |
8 | # The format for tests is a dict of { "test_name" : value to pass to threefive.decode}
9 | ten_tests = {
10 | "Base64": "/DAvAAAAAAAA///wBQb+dGKQoAAZAhdDVUVJSAAAjn+fCAgAAAAALKChijUCAKnMZ1g=",
11 | "Bytes": b"\xfc0\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\x00\x00\x00O%3\x96",
12 | "Hex String": "0XFC301100000000000000FFFFFF0000004F253396",
13 | "Hex Literal": 0xFC301100000000000000FFFFFF0000004F253396,
14 | "Integer": 1439737590925997869941740173214217318917816529814,
15 | "HTTP/HTTPS Streams": "https://futzu.com/xaa.ts",
16 | # "Bad" tests are expected to fail.
17 | "Bad Base64 ": "/DAvAf45AA",
18 | "Bad File": "/you/me/fake.file",
19 | "Bad Integer": -0.345,
20 | " Bad String": "your momma",
21 | }
22 |
23 |
24 | def _decode_test(test_name, test_data):
25 | passed = "✔"
26 | failed = "✘"
27 | print2(f"testing {test_name}\n Data: {test_data}\n")
28 | if decode(test_data):
29 | return passed
30 | return failed
31 |
32 |
33 | def smoke(tests=None):
34 | """
35 | calls threefive.decode using the values in tests.
36 | The format for tests:
37 | { "test_name" : value to pass to threefive.decode}
38 |
39 | example:
40 |
41 | my_tests ={
42 | "Base64": "/DAvAAAAAAAA///wBQb+dGKQoAAZAhdDVUVJSAAAjn+fCAgAAAAALKChijUCAKnMZ1g=",
43 | "Bytes": b"\xfc0\x11\x00\x00\x00\x00\x00\x00\x00\xff\xff\xff\x00\x00\x00O%3\x96"
44 | }
45 |
46 | import threefive
47 | threefive.smoke_test(my_tests)
48 |
49 | """
50 | if not tests:
51 | tests = ten_tests
52 | results = {k: _decode_test(k, v) for k, v in tests.items()}
53 | print2("Smoke Test\n")
54 | for kay, vee in results.items():
55 | print2(f"{kay} {vee}")
56 |
57 |
58 | if __name__ == "__main__":
59 | smoke()
60 |
--------------------------------------------------------------------------------
/threefive/streamtypes.py:
--------------------------------------------------------------------------------
1 | """
2 |
3 | streamtypes.py
4 |
5 | Used by threefive.Stream
6 | On import stream_types generates a complete streamtype_map.
7 |
8 | from .streamtypes import streamtype_map
9 |
10 | """
11 |
12 | streamtype_map = {
13 | 0x00: "Reserved",
14 | 0x01: "MPEG-1 video",
15 | 0x02: "H.262 video",
16 | 0x03: "MPEG-2 audio",
17 | 0x04: "MPEG-2 halved sample rate audio",
18 | 0x05: "MPEG-2 tabled data",
19 | 0x06: "MPEG-2 binary data",
20 | 0x07: "ISO/IEC 13522 (MHEG)",
21 | 0x08: "H.222 and DSM CC",
22 | 0x09: "H.222 and auxiliary data",
23 | 0x0A: "DSM CC multiprotocol encapsulation",
24 | 0x0B: "DSM CC U-N messages",
25 | 0x0C: "DSM CC stream descriptors",
26 | 0x0D: "DSM CC tabled data",
27 | 0x0E: "auxiliary data",
28 | 0x0F: "ADTS AAC ",
29 | 0x10: "MPEG-4 H.263 based video",
30 | 0x11: "MPEG-4 LOAS multi-format framed audio",
31 | 0x12: "MPEG-4 FlexMux",
32 | 0x13: "MPEG-4 FlexMux",
33 | 0x14: "DSM CC ",
34 | 0x15: "ID3",
35 | 0x16: "Sectioned metadata",
36 | 0x17: "DSM CC Data Carousel metadata",
37 | 0x18: "DSM CC Object Carousel metadata",
38 | 0x19: "Synchronized Download Protocol metadata",
39 | 0x1A: "IPMP",
40 | 0x1B: "H.264",
41 | 0x1C: "MPEG-4 raw audio)",
42 | 0x1D: "MPEG-4 text",
43 | 0x1E: "MPEG-4 auxiliary video",
44 | 0x1F: "SVC (MPEG-4 AVC sub-bitstream)",
45 | 0x20: "MVC (MPEG-4 AVC sub-bitstream)",
46 | 0x21: "JPEG 2000 video",
47 | # 0x22 - 0x23:"Reserved.",
48 | 0x24: " H.265",
49 | # 0x25 - 0x41:"Reserved.",
50 | 0x42: "Chinese Video Standard",
51 | # 0x43 - 0x7e:"Reserved.",
52 | 0x7F: " DRM Trash",
53 | 0x80: "H.262 with DES-64-CBC ",
54 | 0x81: "AC-3",
55 | 0x82: "SCTE subtitle",
56 | 0x83: "Dolby TrueHD audio ",
57 | 0x84: "AC-3",
58 | 0x85: "DTS 8 channel audio for Blu-ray",
59 | 0x86: "SCTE-35",
60 | 0x87: "AC-3 up to 16 channel audio for ATSC",
61 | # 0x88 - 0x89:"Privately defined.",
62 | 0x90: "Blu-ray Presentation Graphic Stream (subtitling)",
63 | 0x91: "ATSC DSM CC Network Resources table",
64 | # 0x92 - 0xBF:"Privately defined.",
65 | 0xC0: "DigiCipher II text",
66 | 0xC1: "AC-3 with AES-128-CBC ",
67 | 0xC2: "ATSC DSM CC synchronous data",
68 | # 0xC3 - 0xCE:"Privately defined.",
69 | 0xCF: "ADTS AAC with AES-128-CBC frame encryption",
70 | 0xD0: "Privately defined.",
71 | 0xD1: "BBC Dirac ",
72 | 0xD2: "AVS2 ",
73 | 0xD3: "AVS3 Audio",
74 | 0xD4: "AVS3 Video ",
75 | # 0xD5 - 0xDA:"Privately defined.",
76 | 0xDB: " H.264 with AES-128-CBC slice encryption",
77 | # 0xDC - 0xE9:"Privately defined.",
78 | 0xEA: "Windows janky media v9",
79 | # 0xEB - 0xFB:"Privately defined.",
80 | 0xFC: "KLV",
81 | }
82 |
83 |
84 | others = {
85 | "Reserved": list(range(0x22, 0x23))
86 | + list(range(0x25, 0x41))
87 | + list(range(0x43, 0x7E)),
88 | "Private": list(range(0x88, 0x89))
89 | + list(range(0x92, 0xBF))
90 | + list(range(0xC3, 0xCE))
91 | + list(range(0xD5, 0xDA))
92 | + list(range(0xDC, 0xE9))
93 | + list(range(0xEB, 0xFB))
94 | + list(range(0xFD, 0xFF)),
95 | }
96 |
97 |
98 | def hex_literal(integer):
99 | """
100 | Return hex literal
101 | """
102 | return int(hex(integer), base=16)
103 |
104 |
105 | def add_stream_types(alist, streamtype):
106 | """
107 | add_stream_types dynamically
108 | adds a range of a stream type,
109 | like "Reserved",to streamtype_map
110 | """
111 | for i in alist:
112 | j = hex_literal(i)
113 | streamtype_map[j] = streamtype
114 |
115 |
116 | def mk_streamtype_map(others):
117 | """
118 | mk_streamtype_map dynamically adds
119 | stream types to streamtype_map
120 | """
121 | for k, v in others.items():
122 | add_stream_types(v, k)
123 | keys = list(streamtype_map.keys())
124 | keys.sort()
125 |
126 |
127 | mk_streamtype_map(others)
128 |
--------------------------------------------------------------------------------
/threefive/stuff.py:
--------------------------------------------------------------------------------
1 | """
2 | stuff.py functions and such common to threefive.
3 | """
4 |
5 | from sys import stderr
6 |
7 |
8 | def print2(stuff=b""):
9 | """
10 | print2 prints to 2 aka stderr.
11 | """
12 | print(stuff, file=stderr, flush=True)
13 |
14 |
15 | def dbl_split(data, mark):
16 | """
17 | dbl_split split bytes on mark twice
18 | return mark + split bytes on mark twice.
19 | """
20 | return mark + data.split(mark)[-1].split(mark)[-1]
21 |
--------------------------------------------------------------------------------
/threefive/version.py:
--------------------------------------------------------------------------------
1 | """
2 | threefive.version
3 | from the cli tool run: threefive version
4 | """
5 | version='2.4.99'
6 |
--------------------------------------------------------------------------------
/trigger.md:
--------------------------------------------------------------------------------
1 | # Triggering on SCTE-35 Events with threefive.Stream.
2 |
3 |
4 | ## `option 1` ` pass in a function`
5 | ---
6 | * Most of the Stream methods take an optional arg __func__, a function to be called when a SCTE-35 Cue is found.
7 |
8 | * The __func__ function __must__ take __only one arg__, and that is __a threefive.Cue object__.
9 |
10 | ---
11 |
12 | * I use __sidecar__ files for some of my other projects a __sidecar__ file consists
13 | of __(PTS, Cue)__ pairs, one per line.
14 | * A __sidecar file__ looks this.
15 |
16 |
17 | ```js
18 | a@slow:~$ cat sidecar.txt
19 |
20 |
21 | 41.273211,/DAWAAAAAAAAAP/wBQb+ADi52AAAp77zBQ==
22 | 42.240844,/DAWAAAAAAAAAP/wBQb+ADoZwgAAaVWytQ==
23 | 43.275211,/DAWAAAAAAAAAP/wBQb+ADt5rAAAXIo9lg==
24 | 44.276211,/DAWAAAAAAAAAP/wBQb+ADzZlgAAwI0IyA==
25 | 45.277211,/DAWAAAAAAAAAP/wBQb+AD45gAAA1tIPCQ==
26 | 46.244844,/DAWAAAAAAAAAP/wBQb+AD+ZagAAf8zc/g==
27 | 47.279211,/DAWAAAAAAAAAP/wBQb+AED5VAAAVMj9Dw==
28 | 48.246844,/DAWAAAAAAAAAP/wBQb+AEJZPgAAypfF7w==
29 | 49.281211,/DAWAAAAAAAAAP/wBQb+AEO5KAAAB99quQ==
30 | ```
31 |
32 | One of the ways I use a sidecar file is to exact the SCTE-35 before using ffmpeg to encode to HLS,
33 | and then I use the sidecar file to generate HLS tags and insert them into the ffmpeg m3u8 files in real time.
34 |
35 | * To make a sidecar file, I write a function.
36 |
37 | ```py3
38 |
39 | def mk_sidecar(cue):
40 | """
41 | mk_sidecar generates a sidecar file with the SCTE-35 Cues
42 | """
43 | pts = 0.0
44 | with open("sidecar.txt", "a") as sidecar:
45 | cue.show()
46 | if cue.packet_data.pts:
47 | pts = cue.packet_data.pts
48 | data = f"{pts},{cue.encode()}\n"
49 | sidecar.write(data)
50 |
51 | ```
52 | * The only other step is to call __Stream.decode__ and pass in the mk_sidecar function.
53 |
54 | * Here's the complete example to generate a sidecar file.
55 |
56 | ```py3
57 |
58 | #!/usr/bin/env python3
59 |
60 | import sys
61 | from threefive import Stream
62 |
63 |
64 | def mk_sidecar(cue):
65 | """
66 | mk_sidecar generates a sidecar file with the SCTE-35 Cues
67 | """
68 | pts = 0.0
69 | with open("sidecar.txt", "a") as sidecar:
70 | cue.show()
71 | if cue.packet_data.pts:
72 | pts = cue.packet_data.pts
73 | data = f"{pts},{cue.encode()}\n"
74 | sidecar.write(data)
75 |
76 |
77 | if __name__ == '__main__':
78 | strm = Stream(sys.argv[1])
79 | strm.decode(func=mk_sidecar)
80 |
81 |
82 |
83 | ```
84 | * Run it like this:
85 |
86 | ```py3
87 | pypy3 sidecar_gen.py https://example.com/nmx.ts
88 | ```
89 | ---
90 | * If you want to limit your sidecar file to the SCTE-35 in a specific MPEGTS program, call __decode_program__ instead.
91 |
92 |
93 | ```py3
94 | if __name__ == '__main__':
95 | the_program = 3
96 | strm = Stream(sys.argv[1])
97 | strm.decode_program(the_program, func=mk_sidecar)
98 |
99 | ```
100 | ---
101 | * To limit the sidecar file to SCTE-35 from a list of pids, call __decode_pids__.
102 |
103 | ```py3
104 | if __name__ == '__main__':
105 | scte35_pids =[259,1023,399]
106 | strm = Stream(sys.argv[1])
107 | strm.decode_pids(scte35_pids, func=mk_sidecar)
108 |
109 | ```
110 | ---
111 | * To parse the video and then pipe it to ffmpeg or another program, __Stream.proxy__ writes the video stream sys.stdout.
112 |
113 | ```py3
114 | if __name__ == '__main__':
115 | scte35_pids =[259,1023,399]
116 | strm = Stream(sys.argv[1])
117 | strm.proxy(func=mk_sidecar)
118 |
119 | ```
120 |
121 | ---
122 |
123 | ## `option 2` `Stream.decode_next`
124 |
125 | * __Stream.decode_next__ returns the next Cue found.
126 | * This example uses a while loop with __Stream.decode_next__.
127 | * using __Stream.decode_next__ gives you more control over processing the Cue.
128 | ```py3
129 |
130 | import sys
131 | import threefive
132 | from new_reader import reader
133 |
134 | def mk_sidecar(cue):
135 | """
136 | mk_sidecar generates a sidecar file with the SCTE-35 Cues
137 | """
138 | pts = 0.0
139 | with open("sidecar.txt", "a") as sidecar:
140 | cue.show()
141 | if cue.packet_data.pts:
142 | pts = cue.packet_data.pts
143 | data = f"{pts},{cue.encode()}\n"
144 | sidecar.write(data)
145 |
146 |
147 | def do():
148 | arg = sys.argv[1]
149 | with reader(arg) as tsdata:
150 | st = threefive.Stream(tsdata)
151 | while True:
152 | cue = st.decode_next()
153 | if not cue:
154 | return False
155 | if cue:
156 | mk_sidecar(cue)
157 |
158 |
159 | if __name__ == "__main__":
160 | do()
161 |
162 | ```
163 |
--------------------------------------------------------------------------------
/xml.md:
--------------------------------------------------------------------------------
1 | # Xml as of v2.4.95
2 |
3 | __I strongly suggest using the xml+binary format__ for DASH, it is very straight forward, very compact, and the SCTE-35 data is exactly the same as regular SCTE-35. __use xml+bin for DASH__
4 |
5 | #### xml in the Cli
6 | * [SCTE-35 xml input](#xml-input)
7 | * [SCTE-35 xml output](#xml-output)
8 | * [SCTE-35 xml output from MPEGTS](#xml-output-from-mpegts-video)
9 |
10 | #### xml in the Cue class
11 | * [SCTE-35 xml input](#xml-as-input)
12 | * [SCTE-35 xml output](#the-cue-class-can-return-xml-as-output)
13 | * [removing or changing the scte35 namespace](#removing-or-changing-the-namespace)
14 |
15 | # Cli
16 |
17 | ## Xml input
18 |
19 | * SCTE-35 __xml__ and SCTE-35 __xmlbin__ can be encoded to base64, bytes, hex, int, or json.
20 |
21 | ### xmlbin
22 |
23 | * parse mpegts video and display scte-35 in xmlbin format.
24 |
25 | threefive xmlbin sixed.ts
26 |
27 |
28 | * convert to xmlbin format
29 |
30 | threefive '/DAgAAAAAAAAAP/wDwUAAAABf0/+AFJlwAABAAAAALQOZyE=' xmlbin
31 | ```xml
32 |
33 | /DAgAAAAAAAAAP/wDwUAAAABf0/+AFJlwAABAAAAALQOZyE=
34 |
35 | ```
36 |
37 | * write to a file in xmlbin format
38 |
39 | a@fu:~$ threefive '/DAgAAAAAAAAAP/wDwUAAAABf0/+AFJlwAABAAAAALQOZyE=' xmlbin 2> xmlbin.xml
40 |
41 | * read from the file and convert to bytes
42 |
43 | a@fu:~$ threefive bytes < xmlbin.xml
44 | b'\xfc0\x00\x00\x00\x00\x00\x00\x00\xff\xf0\x0f\x05\x00\x00\x00\x01\x7fO\xfe\x00Re\xc0\x00\x01\x00\x00\x00\x00\xb4\x0eg!'
45 |
46 | * read from a file and convert to base64
47 |
48 | a@fu:~$ threefive base64 < xmlbin.xml
49 | /DAgAAAAAAAAAP/wDwUAAAABf0/+AFJlwAABAAAAALQOZyE=
50 |
51 | * read from a file and convert to hex
52 |
53 | a@fu:~$ threefive hex < xmlbin.xml
54 | 0xfc302000000000000000fff00f05000000017f4ffe005265c0000100000000b40e6721
55 |
56 | * read from a file and convert to plain xml
57 |
58 | a@fu:~$ threefive xml < xmlbin.xml
59 | ```xml
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 | ```
68 | ## Xml
69 |
70 |
71 | * Xml to Base64
72 |
73 | ```js
74 | threefive < xml.xml
75 |
76 | /DAsAAAAAAAAAP/wBQb+7YaD1QAWAhRDVUVJAADc8X+/DAVPVkxZSSIAAJ6Gk2Q=
77 |
78 | ```
79 |
80 | * Xml to hex
81 |
82 | ```js
83 | threefive hex < xml.xml
84 | 0xfc302c00000000000000fff00506feed8683d500160214435545490000dcf17fbf0c054f564c59492200009e869364
85 |
86 | ```
87 |
88 | * Xml to int
89 | ```js
90 | threefive int < xml.xml
91 | 151622312799635087445131038116901140411521203255173124307448868984487395583746158940007186416525810106184013091684
92 | ```
93 |
94 | ### Xml output
95 | * the cli can convert SCTE-35 base64, hex, or json to xml
96 | ```js
97 | a@fu:~/build/SCTE35_threefive$ threefive xml '0xfc302c00000000000000fff00506feed8683d500160214435545490000dcf17fbf0c054f564c59492200009e869364'
98 | ```xml
99 |
100 |
101 |
102 |
103 |
104 |
105 |
106 | 4f564c5949
107 |
108 |
109 | ```
110 |
111 | ### Xml output from mpegts video
112 |
113 | * MPEGTS streams can be parsed for SCTE-35 and the output encoded in Xml
114 |
115 | ```js
116 | threefive xml sixed.ts
117 | ```
118 | ```xml
119 |
120 |
121 |
122 |
123 |
124 |
125 |
126 |
127 |
128 |
129 |
130 | 10100000
131 |
132 |
133 |
134 | ```
135 |
136 | * threefive prints output to stderr, stdout is used for piping data.
137 | * To save the output of the cli tool redirect 2.
138 | ```js
139 | threefive xmlbin sixed.ts 2> fu.xml
140 | ```
141 |
142 | # Xml with the Cue class.
143 |
144 | ### The Cue class can return xml as output
145 |
146 | ```py3
147 | a@fu:~/build/SCTE35_threefive$ pypy3
148 | Python 3.9.16 (7.3.11+dfsg-2+deb12u2, May 20 2024, 22:08:06)
149 | [PyPy 7.3.11 with GCC 12.2.0] on linux
150 | Type "help", "copyright", "credits" or "license" for more information.
151 | >>>> from threefive import Cue
152 | >>>> cue=Cue('/DA4AAAAAAAA///wBQb+AKpFLgAiAiBDVUVJAAAAA3//AAApPWwDDEFCQ0QwMTIzNDU2SBAAABZE5vg=')
153 | >>>> cue.decode()
154 | True
155 | >>>> cue.xml(xmlbin=False)
156 | ```
157 | ```xml
158 |
159 |
160 |
161 |
162 |
163 |
164 |
165 | ABCD0123456H
166 |
167 |
168 | ```
169 | * By default, the Cue class returns xml in the xml+bin format
170 | ```py3
171 | >>>> cue.xml()
172 | ```
173 | ```xml
174 |
175 | /DA4AAAAAAAA///wBQb+AKpFLgAiAiBDVUVJAAAAA3//AAApPWwDDEFCQ0QwMTIzNDU2SBAAABZE5vg=
176 |
177 | ```
178 |
179 | ### Xml as input
180 |
181 | * xml can now be passed in to a Cue instance when initialized
182 | * both xml and xml+bin formats can be used.
183 | ```xml
184 | x="
185 |
186 | /DA4AAAAAAAA///wBQb+AKpFLgAiAiBDVUVJAAAAA3//AAApPWwDDEFCQ0QwMTIzNDU2SBAAABZE5vg=
187 |
188 | "
189 | ```
190 | ```py3
191 | >>>> cue2=Cue(x)
192 |
193 | >>>> cue2.xml(xmlbin=False)
194 | ```
195 | ```xml
196 |
197 |
198 |
199 |
200 |
201 |
202 |
203 | ABCD0123456H
204 |
205 |
206 | ```
207 |
208 | ### Removing or changing the namespace
209 |
210 | * the namespace can be removed or changed in either the xml or xml+bin format
211 | * to remove the scte35 namespace, set the optional ns arg to an empty string
212 |
213 | ```py3
214 | >>>> cue.xml(xmlbin=False,ns='')
215 | ```
216 | ```xml
217 |
218 |
219 |
220 |
221 |
222 |
223 |
224 | ABCD0123456H
225 |
226 |
227 | ```
228 |
229 |
--------------------------------------------------------------------------------