m3u8 0.8.2 → 1.8.1

data/spec/lib/m3u8/round_trip_spec.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe 'Round-trip serialization' do
+  def read_fixture(name)
+    File.read("spec/fixtures/#{name}")
+  end
+
+  def parse(text)
+    M3u8::Playlist.read(text)
+  end
+
+  context 'exact string round-trip (canonical fixtures)' do
+    %w[
+      event_playlist.m3u8
+      daterange_playlist.m3u8
+      master_full.m3u8
+      encrypted_discontinuity.m3u8
+      ll_hls_advanced.m3u8
+    ].each do |fixture|
+      it "round-trips #{fixture}" do
+        text = read_fixture(fixture)
+        expect(parse(text).to_s).to eq(text)
+      end
+    end
+  end
+
+  context 'semantic round-trip (non-canonical fixtures)' do
+    it 'round-trips master.m3u8' do
+      text = read_fixture('master.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.master?).to be true
+      expect(second.items.size).to eq(first.items.size)
+      expect(second.independent_segments).to eq(true)
+
+      item = second.items[2]
+      expect(item).to be_a(M3u8::PlaylistItem)
+      expect(item.bandwidth).to eq(5_042_000)
+      expect(item.codecs).to eq('avc1.640028,mp4a.40.2')
+    end
+
+    it 'round-trips playlist.m3u8' do
+      text = read_fixture('playlist.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.master?).to be false
+      expect(second.items.size).to eq(first.items.size)
+      expect(second.version).to eq(4)
+      expect(second.sequence).to eq(1)
+      expect(second.type).to eq('VOD')
+    end
+
+    it 'round-trips master_v13.m3u8' do
+      text = read_fixture('master_v13.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.version).to eq(13)
+      item = second.items[1]
+      expect(item).to be_a(M3u8::PlaylistItem)
+      expect(item.stable_variant_id).to eq('hd-1080')
+      expect(item.video_range).to eq('SDR')
+      expect(item.pathway_id).to eq('CDN-A')
+      expect(item.score).to eq(12.5)
+      expect(item.supplemental_codecs)
+        .to eq('dvh1.05.06/db4g')
+    end
+
+    it 'round-trips content_steering.m3u8' do
+      text = read_fixture('content_steering.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.items.size).to eq(first.items.size)
+      defines = second.items.grep(M3u8::DefineItem)
+      expect(defines.size).to eq(2)
+
+      steering = second.items.find do |i|
+        i.is_a?(M3u8::ContentSteeringItem)
+      end
+      expect(steering.server_uri)
+        .to eq('https://example.com/steering')
+      expect(steering.pathway_id).to eq('CDN-A')
+    end
+
+    it 'round-trips ll_hls_playlist.m3u8' do
+      text = read_fixture('ll_hls_playlist.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.server_control.can_skip_until)
+        .to eq(24.0)
+      expect(second.part_inf.part_target).to eq(0.5)
+      expect(second.items.size).to eq(first.items.size)
+    end
+
+    it 'round-trips variant_audio.m3u8' do
+      text = read_fixture('variant_audio.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.items.size).to eq(first.items.size)
+      media = second.items.grep(M3u8::MediaItem)
+      expect(media.size).to eq(6)
+      expect(media.first.group_id).to eq('audio-lo')
+    end
+
+    it 'round-trips variant_angles.m3u8' do
+      text = read_fixture('variant_angles.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.items.size).to eq(first.items.size)
+      media = second.items.grep(M3u8::MediaItem)
+      expect(media.size).to eq(9)
+      types = media.map(&:type).uniq.sort
+      expect(types).to eq(%w[AUDIO CLOSED-CAPTIONS
+                             SUBTITLES VIDEO])
+    end
+
+    it 'round-trips gap_playlist.m3u8' do
+      text = read_fixture('gap_playlist.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.master?).to be false
+      expect(second.items.size).to eq(first.items.size)
+
+      item = second.items[0]
+      expect(item).to be_a(M3u8::BitrateItem)
+      expect(item.bitrate).to eq(128)
+
+      item = second.items[2]
+      expect(item).to be_a(M3u8::GapItem)
+    end
+
+    it 'round-trips session_data.m3u8' do
+      text = read_fixture('session_data.m3u8')
+      first = parse(text)
+      second = parse(first.to_s)
+
+      expect(second.items.size).to eq(first.items.size)
+      item = second.items[0]
+      expect(item).to be_a(M3u8::SessionDataItem)
+      expect(item.data_id).to eq('com.example.lyrics')
+    end
+  end
+end

data/spec/lib/m3u8/scte35_bit_reader_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::Scte35BitReader do
+  describe '#read_bits' do
+    it 'should read 8-bit values' do
+      reader = described_class.new("\xAB")
+      expect(reader.read_bits(8)).to eq(0xAB)
+    end
+
+    it 'should read 1-bit values' do
+      reader = described_class.new("\xA0")
+      expect(reader.read_bits(1)).to eq(1)
+      expect(reader.read_bits(1)).to eq(0)
+      expect(reader.read_bits(1)).to eq(1)
+      expect(reader.read_bits(1)).to eq(0)
+    end
+
+    it 'should read 12-bit values' do
+      reader = described_class.new("\xAB\xCD")
+      expect(reader.read_bits(12)).to eq(0xABC)
+    end
+
+    it 'should read 16-bit values' do
+      reader = described_class.new("\xAB\xCD")
+      expect(reader.read_bits(16)).to eq(0xABCD)
+    end
+
+    it 'should read 32-bit values' do
+      reader = described_class.new("\x12\x34\x56\x78")
+      expect(reader.read_bits(32)).to eq(0x12345678)
+    end
+
+    it 'should read 33-bit values' do
+      # 1 followed by 32 zeros = 2^32
+      reader = described_class.new("\x80\x00\x00\x00\x00")
+      expect(reader.read_bits(33)).to eq(2**32)
+    end
+
+    it 'should read 33-bit values after partial byte reads' do
+      # Simulates: time_specified(1), reserved(6), pts_time(33)
+      # 1_111111_0 00000000 00000000 00000000 00000001
+      reader = described_class.new("\xFE\x00\x00\x00\x01")
+      expect(reader.read_bits(1)).to eq(1)
+      expect(reader.read_bits(6)).to eq(0x3F)
+      expect(reader.read_bits(33)).to eq(1)
+    end
+
+    it 'should read values across byte boundaries' do
+      reader = described_class.new("\xF0\x0F")
+      expect(reader.read_bits(4)).to eq(0xF)
+      expect(reader.read_bits(8)).to eq(0x00)
+      expect(reader.read_bits(4)).to eq(0xF)
+    end
+  end
+
+  describe '#read_flag' do
+    it 'should return true for 1' do
+      reader = described_class.new("\x80")
+      expect(reader.read_flag).to be true
+    end
+
+    it 'should return false for 0' do
+      reader = described_class.new("\x00")
+      expect(reader.read_flag).to be false
+    end
+  end
+
+  describe '#read_bytes' do
+    it 'should read raw bytes' do
+      reader = described_class.new("\xDE\xAD\xBE\xEF")
+      expect(reader.read_bytes(2)).to eq("\xDE\xAD".b)
+      expect(reader.read_bytes(2)).to eq("\xBE\xEF".b)
+    end
+  end
+
+  describe '#skip_bits' do
+    it 'should advance the position' do
+      reader = described_class.new("\xFF\x42")
+      reader.skip_bits(8)
+      expect(reader.read_bits(8)).to eq(0x42)
+    end
+
+    it 'should skip sub-byte amounts' do
+      reader = described_class.new("\xF5")
+      reader.skip_bits(4)
+      expect(reader.read_bits(4)).to eq(0x5)
+    end
+  end
+
+  describe '#bytes_remaining' do
+    it 'should return remaining bytes' do
+      reader = described_class.new("\x01\x02\x03\x04")
+      expect(reader.bytes_remaining).to eq(4)
+      reader.read_bits(8)
+      expect(reader.bytes_remaining).to eq(3)
+    end
+
+    it 'should account for partial byte reads' do
+      reader = described_class.new("\x01\x02")
+      reader.read_bits(4)
+      expect(reader.bytes_remaining).to eq(1)
+    end
+  end
+end

data/spec/lib/m3u8/scte35_segmentation_descriptor_spec.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::Scte35SegmentationDescriptor do
+  # Builds a full SCTE-35 hex string with a time_signal command and descriptors
+  def build_hex_with_descriptors(descriptor_bytes)
+    # time_signal with pts=90000: FE 00 01 5F 90 (5 bytes, type 0x06)
+    cmd_bytes = 'FE00015F90'
+    cmd_len = 5
+    desc_loop_length = descriptor_bytes.length
+    desc_hex = descriptor_bytes.map { |b| format('%02X', b) }.join
+    desc_loop_hex = format('%04X', desc_loop_length)
+
+    # section_length = 11(header) + cmd_len + 2(desc_loop_len) + desc_loop + 4(CRC)
+    section_length = 11 + cmd_len + 2 + desc_loop_length + 4
+    header = splice_info_header(section_length, cmd_len)
+
+    "0x#{header}06#{cmd_bytes}#{desc_loop_hex}#{desc_hex}DEADBEEF"
+  end
+
+  def splice_info_header(section_length, cmd_length)
+    section_header = format('%04X', 0x3000 | section_length)
+    tier_cmd = format('%06X', (0xFFF << 12) | cmd_length)
+    "FC#{section_header}00000000000000#{tier_cmd}"
+  end
+
+  # Builds segmentation_descriptor bytes (tag=0x02, identifier=CUEI)
+  def segmentation_descriptor(fields)
+    # descriptor_tag(8): 0x02
+    # descriptor_length(8): computed
+    # identifier(32): CUEI = 0x43554549
+    # segmentation_event_id(32)
+    # segmentation_event_cancel_indicator(1) + reserved(7)
+    # if not cancelled:
+    #   program_segmentation_flag(1)=1 + segmentation_duration_flag(1)
+    #   + delivery_not_restricted_flag(1)=1 + reserved(5)=11111
+    #   if duration_flag: segmentation_duration(40)
+    #   segmentation_upid_type(8) + segmentation_upid_length(8)
+    #   + upid data
+    #   segmentation_type_id(8) + segment_num(8) + segments_expected(8)
+    bytes = [0x43, 0x55, 0x45, 0x49] # CUEI identifier
+    bytes += to_bytes(fields[:event_id], 4)
+
+    if fields[:cancel]
+      bytes += [0xFF] # cancel=1, reserved=1111111
+    else
+      bytes << 0x7F # cancel=0, reserved=1111111
+      duration_flag = fields[:duration] ? 1 : 0
+      # program_seg=1, duration_flag, delivery_not_restricted=1, reserved=11111
+      flags = (1 << 7) | (duration_flag << 6) | (1 << 5) | 0x1F
+      bytes << flags
+
+      if fields[:duration]
+        bytes += to_bytes(fields[:duration], 5) # 40-bit duration
+      end
+
+      upid = fields[:upid] || ''
+      bytes << (fields[:upid_type] || 0)
+      bytes << upid.length
+      bytes += upid.bytes if upid.length.positive?
+
+      bytes << fields[:type_id]
+      bytes << (fields[:segment_num] || 0)
+      bytes << (fields[:segments_expected] || 0)
+    end
+
+    # Prepend tag and length
+    [0x02, bytes.length] + bytes
+  end
+
+  def to_bytes(value, count)
+    count.times.map { |i| (value >> (8 * (count - 1 - i))) & 0xFF }
+  end
+
+  describe 'parsing via Scte35.parse' do
+    it 'should parse a segmentation descriptor with ad-start type' do
+      desc = segmentation_descriptor(
+        event_id: 0x00000001, type_id: 0x30,
+        segment_num: 0, segments_expected: 0
+      )
+      hex = build_hex_with_descriptors(desc)
+      result = M3u8::Scte35.parse(hex)
+
+      expect(result.descriptors.length).to eq(1)
+      seg = result.descriptors.first
+      expect(seg).to be_a(described_class)
+      expect(seg.segmentation_event_id).to eq(1)
+      expect(seg.segmentation_type_id).to eq(0x30)
+      expect(seg.segment_num).to eq(0)
+      expect(seg.segments_expected).to eq(0)
+    end
+
+    it 'should parse a segmentation descriptor with duration' do
+      desc = segmentation_descriptor(
+        event_id: 0x00000002, type_id: 0x34,
+        duration: 2_700_000, segment_num: 1, segments_expected: 2
+      )
+      hex = build_hex_with_descriptors(desc)
+      result = M3u8::Scte35.parse(hex)
+      seg = result.descriptors.first
+
+      expect(seg.segmentation_duration).to eq(2_700_000)
+      expect(seg.segmentation_type_id).to eq(0x34)
+      expect(seg.segment_num).to eq(1)
+      expect(seg.segments_expected).to eq(2)
+    end
+
+    it 'should parse a segmentation descriptor with UPID' do
+      desc = segmentation_descriptor(
+        event_id: 0x00000003, type_id: 0x30,
+        upid_type: 0x09, upid: 'SIGNAL123'
+      )
+      hex = build_hex_with_descriptors(desc)
+      result = M3u8::Scte35.parse(hex)
+      seg = result.descriptors.first
+
+      expect(seg.segmentation_upid_type).to eq(0x09)
+      expect(seg.segmentation_upid).to eq('SIGNAL123')
+    end
+
+    it 'should parse a cancelled segmentation descriptor' do
+      desc = segmentation_descriptor(event_id: 0x00000004, cancel: true)
+      hex = build_hex_with_descriptors(desc)
+      result = M3u8::Scte35.parse(hex)
+      seg = result.descriptors.first
+
+      expect(seg.segmentation_event_id).to eq(4)
+      expect(seg.segmentation_event_cancel_indicator).to be true
+      expect(seg.segmentation_type_id).to be_nil
+    end
+
+    it 'should store raw bytes for unknown descriptor tags' do
+      # Unknown tag 0xFF with 4 bytes of identifier + 2 bytes data
+      unknown_desc = [0xFF, 0x06, 0x43, 0x55, 0x45, 0x49, 0xAA, 0xBB]
+      hex = build_hex_with_descriptors(unknown_desc)
+      result = M3u8::Scte35.parse(hex)
+
+      expect(result.descriptors.length).to eq(1)
+      expect(result.descriptors.first).to be_a(String)
+    end
+  end
+end

data/spec/lib/m3u8/scte35_spec.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::Scte35 do
+  describe '.parse' do
+    it 'should parse a splice_null command' do
+      # splice_info_section with splice_null (type 0x00):
+      #   table_id=0xFC, section_length=17, protocol=0, pts_adjustment=0
+      #   cw_index=0, tier=0xFFF, command_length=0, command_type=0x00
+      #   descriptor_loop_length=0, crc=0xDEADBEEF
+      hex = '0xFC301100000000000000FFF000000000DEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.table_id).to eq(0xFC)
+      expect(result.pts_adjustment).to eq(0)
+      expect(result.tier).to eq(0xFFF)
+      expect(result.splice_command_type).to eq(0x00)
+      expect(result.splice_command).to be_a(M3u8::Scte35SpliceNull)
+      expect(result.descriptors).to eq([])
+    end
+
+    it 'should round-trip hex string via to_s' do
+      hex = '0xFC301100000000000000FFF000000000DEADBEEF'
+      result = described_class.parse(hex)
+      expect(result.to_s).to eq(hex)
+    end
+
+    it 'should store raw bytes for unknown command types' do
+      # command_type=0xFF with 2 bytes of command data (0xAABB)
+      # section_length=19 to accommodate extra 2 bytes
+      hex = '0xFC301300000000000000FFF002FFAABB0000DEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.splice_command_type).to eq(0xFF)
+      expect(result.splice_command).to eq("\xAA\xBB".b)
+    end
+
+    it 'should parse nonzero pts_adjustment' do
+      # pts_adjustment=300 (0x12C): encrypted=0, algo=0, pts=300
+      # 0_000000_0_00000000_00000000_00000001_00101100
+      # bytes: 00 00 00 01 2C
+      hex = '0xFC301100000000012C00FFF000000000DEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.pts_adjustment).to eq(300)
+    end
+
+    it 'should handle hex strings without 0x prefix' do
+      hex = 'FC301100000000000000FFF000000000DEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.table_id).to eq(0xFC)
+      expect(result.splice_command_type).to eq(0x00)
+    end
+
+    it 'should parse descriptors with 0xFFF command length' do
+      # time_signal (type 0x06) with splice_command_length=0xFFF
+      # and a descriptor present
+      # time_signal: time_specified=1, pts=90000 (5 bytes)
+      # descriptor: tag=0xFF, length=6, identifier=CUEI, data=0xAABB
+      hex = '0xFC301E00000000000000FFFFFF06FE00015F900008FF0643554549AABBDEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.splice_command_type).to eq(0x06)
+      expect(result.splice_command.pts_time).to eq(90_000)
+      expect(result.descriptors.length).to eq(1)
+      expect(result.descriptors.first).to be_a(String)
+    end
+
+    it 'should consume remaining bytes for unknown type with 0xFFF' do
+      # unknown command type 0xFF with 0xFFF length
+      # command data is everything up to CRC (no descriptors per spec)
+      # section_length = 11(header) + 3(command) + 4(CRC) = 18
+      hex = '0xFC301200000000000000FFFFFFFFAABBCCDEADBEEF'
+      result = described_class.parse(hex)
+
+      expect(result.splice_command_type).to eq(0xFF)
+      expect(result.splice_command).to eq("\xAA\xBB\xCC".b)
+      expect(result.descriptors).to eq([])
+    end
+
+    it 'should raise ParseError for truncated data' do
+      hex = '0xFC30'
+      expect { described_class.parse(hex) }
+        .to raise_error(M3u8::Scte35::ParseError, /invalid SCTE-35 data/)
+    end
+
+    it 'should raise ParseError for empty hex string' do
+      expect { described_class.parse('0x') }
+        .to raise_error(M3u8::Scte35::ParseError, /invalid SCTE-35 data/)
+    end
+  end
+end

data/spec/lib/m3u8/scte35_splice_insert_spec.rb

@@ -0,0 +1,185 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::Scte35SpliceInsert do
+  def build_splice_insert_hex(command_bytes, command_length: nil)
+    cmd_len = command_length || command_bytes.length
+    # section_length = 11(header) + cmd_len + 2(desc_loop) + 4(CRC)
+    section_length = 11 + cmd_len + 6
+    header = splice_info_header(section_length, cmd_len)
+    command_hex = command_bytes.map { |b| format('%02X', b) }.join
+    desc_and_crc = '0000DEADBEEF'
+    "0x#{header}05#{command_hex}#{desc_and_crc}"
+  end
+
+  def splice_info_header(section_length, cmd_length)
+    table_id = 'FC'
+    section_header = format('%04X', 0x3000 | section_length)
+    proto_and_pts = '000000000000'
+    cw_index = '00'
+    tier_cmd = format('%06X', (0xFFF << 12) | cmd_length)
+    "#{table_id}#{section_header}#{proto_and_pts}#{cw_index}#{tier_cmd}"
+  end
+
+  describe '.parse_from' do
+    it 'should parse an ad-start splice_insert' do
+      # splice_event_id(32): 0x00000001
+      # splice_event_cancel_indicator(1): 0
+      # reserved(7): 1111111
+      # out_of_network_indicator(1): 1
+      # program_splice_flag(1): 1
+      # duration_flag(1): 0
+      # splice_immediate_flag(1): 0
+      # reserved(4): 1111
+      # splice_time: time_specified(1)=1, reserved(6)=111111, pts(33)=90000
+      # unique_program_id(16): 0x0001
+      # avail_num(8): 0
+      # avails_expected(8): 0
+      #
+      # pts_time 90000 = 0x15F90:
+      # time_specified(1)=1, reserved(6)=111111, pts(33)=0x00015F90
+      # 1_111111_0_00000000_00000000_00010101_11111001_0000...
+      # Wait, 33 bits of 90000 = 0x15F90:
+      # binary: 0_00000000_00000001_01011111_10010000
+      # with prefix: 1_111111_0_00000000_00000001_01011111_10010000
+      # bytes: FE 00 00 01 5F 90 ... but that's 6 bytes (48 bits) for 40 bits
+      #
+      # Actually: 1+6+33 = 40 bits = 5 bytes:
+      # 1_111111_0 00000000 00000001 01011111 10010000
+      # = FE 00 01 5F 90
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x01, # splice_event_id = 1
+        0x7F,                   # cancel=0, reserved=1111111
+        0xCF,                   # out=1, program=1, duration=0, immediate=0, reserved=1111
+        0xFE, 0x00, 0x01, 0x5F, 0x90, # splice_time: specified=1, pts=90000
+        0x00, 0x01,             # unique_program_id = 1
+        0x00,                   # avail_num = 0
+        0x00                    # avails_expected = 0
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd).to be_a(described_class)
+      expect(cmd.splice_event_id).to eq(1)
+      expect(cmd.out_of_network_indicator).to be true
+      expect(cmd.pts_time).to eq(90_000)
+      expect(cmd.unique_program_id).to eq(1)
+      expect(cmd.avail_num).to eq(0)
+      expect(cmd.avails_expected).to eq(0)
+    end
+
+    it 'should parse a cancelled splice event' do
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x02, # splice_event_id = 2
+        0xFF                    # cancel=1, reserved=1111111
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd.splice_event_id).to eq(2)
+      expect(cmd.splice_event_cancel_indicator).to be true
+      expect(cmd.out_of_network_indicator).to be_nil
+      expect(cmd.pts_time).to be_nil
+    end
+
+    it 'should parse splice_insert with break duration' do
+      # out=1, program=1, duration=1, immediate=0, reserved=1111
+      # splice_time: specified=1, pts=90000
+      # break_duration: auto_return(1)=1, reserved(6)=111111, duration(33)=2700000
+      # 2700000 = 0x293370
+      # 1_111111_0_00000000_00000000_00101001_00110011_01110000
+      # Wait, 33 bits: 0_00000000_00101001_00110011_01110000
+      # = 00 29 33 70 in the last 4 bytes, first byte has auto_return+reserved+MSB
+      # 1_111111_0 00000000 00101001 00110011 01110000
+      # = FE 00 29 33 70
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x03, # splice_event_id = 3
+        0x7F,                   # cancel=0, reserved=1111111
+        0xEF,                   # out=1, program=1, duration=1, immediate=0, reserved=1111
+        0xFE, 0x00, 0x01, 0x5F, 0x90, # splice_time: specified=1, pts=90000
+        0xFE, 0x00, 0x29, 0x32, 0xE0, # break_duration: auto=1, dur=2700000
+        0x00, 0x01,             # unique_program_id = 1
+        0x00,                   # avail_num = 0
+        0x02                    # avails_expected = 2
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd.break_duration).to eq(2_700_000)
+      expect(cmd.break_auto_return).to be true
+      expect(cmd.avails_expected).to eq(2)
+    end
+
+    it 'should parse an immediate splice (no PTS)' do
+      # out=1, program=1, duration=0, immediate=1, reserved=1111
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x04, # splice_event_id = 4
+        0x7F,                   # cancel=0, reserved=1111111
+        0xDF,                   # out=1, program=1, duration=0, immediate=1, reserved=1111
+        0x00, 0x01,             # unique_program_id = 1
+        0x00,                   # avail_num = 0
+        0x00                    # avails_expected = 0
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd.pts_time).to be_nil
+      expect(cmd.out_of_network_indicator).to be true
+      expect(cmd.splice_event_id).to eq(4)
+    end
+
+    it 'should parse component mode splice_insert' do
+      # out=1, program=0, duration=0, immediate=0, reserved=1111
+      # 1_0_0_0_1111 = 0x8F
+      # component_count=1, component_tag=0x22,
+      # splice_time: specified=1, pts=90000
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x01, # splice_event_id = 1
+        0x7F,                   # cancel=0, reserved=1111111
+        0x8F,                   # out=1, program=0, duration=0, immediate=0, reserved=1111
+        0x01,                   # component_count = 1
+        0x22,                   # component_tag = 0x22
+        0xFE, 0x00, 0x01, 0x5F, 0x90, # splice_time: specified=1, pts=90000
+        0x00, 0x01,             # unique_program_id = 1
+        0x00,                   # avail_num = 0
+        0x00                    # avails_expected = 0
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd).to be_a(described_class)
+      expect(cmd.splice_event_id).to eq(1)
+      expect(cmd.out_of_network_indicator).to be true
+      expect(cmd.pts_time).to be_nil
+      expect(cmd.unique_program_id).to eq(1)
+    end
+
+    it 'should parse component mode with immediate flag' do
+      # out=1, program=0, duration=0, immediate=1, reserved=1111
+      # 1_0_0_1_1111 = 0x9F
+      command_bytes = [
+        0x00, 0x00, 0x00, 0x05, # splice_event_id = 5
+        0x7F,                   # cancel=0, reserved=1111111
+        0x9F,                   # out=1, program=0, duration=0, immediate=1, reserved=1111
+        0x02,                   # component_count = 2
+        0x10,                   # component_tag = 0x10
+        0x20,                   # component_tag = 0x20
+        0x00, 0x01,             # unique_program_id = 1
+        0x00,                   # avail_num = 0
+        0x00                    # avails_expected = 0
+      ]
+      hex = build_splice_insert_hex(command_bytes)
+      result = M3u8::Scte35.parse(hex)
+      cmd = result.splice_command
+
+      expect(cmd.splice_event_id).to eq(5)
+      expect(cmd.unique_program_id).to eq(1)
+    end
+  end
+end

data/spec/lib/m3u8/scte35_splice_null_spec.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe M3u8::Scte35SpliceNull do
+  describe '#new' do
+    it 'should create an empty splice null command' do
+      command = described_class.new
+      expect(command).to be_a(described_class)
+    end
+  end
+end