lib/streams/atsc.py

"""
MIT License

Copyright (C) 2021 ROCKY4546
https://github.com/rocky4546

This file is part of Cabernet

Permission is hereby granted, free of charge, to any person obtaining a copy of this software
and associated documentation files (the "Software"), to deal in the Software without restriction,
including without limitation the rights to use, copy, modify, merge, publish, distribute,
sublicense, and/or sell copies of the Software, and to permit persons to whom the Software
is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or
substantial portions of the Software.
"""

import binascii
import struct
import datetime
import logging
import lib.common.utils as utils
from lib.common.algorithms import Crc
from lib.common.models import CrcModels

ATSC_EXTENDED_CHANNEL_DESCR_TAG = b'\xA0'
ATSC_SERVICE_LOCATION_DESCR_TAG = b'\xA1'
ATSC_VIRTUAL_CHANNEL_TABLE_TAG = b'\xC8'
ATSC_MASTER_GUIDE_TABLE_TAG = b'\xC7'
ATSC_SERVICE_DESCR_TABLE_TAG = b'\x42'
MPEG2_PROGRAM_SYSTEM_TIME_TABLE_TAG = b'\xCD'
MPEG2_PROGRAM_ASSOCIATION_TABLE_TAG = b'\x00'
MPEG2_CONDITIONAL_ACCESS_TABLE_TAG = b'\x01'
MPEG2_PROGRAM_MAP_TABLE_TAG = b'\x02'

ATSC_MSG_LEN = 188
LEAP_SECONDS_1980 = 19
LEAP_SECONDS_2021 = 37  # this has not changed since 2017


class ATSCMsg:
    # class that generates most of the ATSC UDP protocol messages


    # UDP msgs for ATSC
    # https://www.atsc.org/wp-content/uploads/2015/03/Program-System-Information-Protocol-for-Terrestrial-Broadcast-and-Cable-1.pdf

    def __init__(self):
        self.logger = logging.getLogger(__name__)
        models = CrcModels()
        crc32_mpeg_model = models.get_params('crc-32-mpeg')
        self.crc_width = crc32_mpeg_model['width']
        self.crc_poly = crc32_mpeg_model['poly']
        self.crc_reflect_in = crc32_mpeg_model['reflect_in']
        self.crc_xor_in = crc32_mpeg_model['xor_in']
        self.crc_reflect_out = crc32_mpeg_model['reflect_out']
        self.crc_xor_out = crc32_mpeg_model['xor_out']
        self.crc_table_idx_width = 8
        self.atsc_blank_section = b'\x47\x1f\xff\x10\x00'.ljust(ATSC_MSG_LEN, b'\xff')
        self.type_strings = []
        self.msg_counter = {}

    def gen_crc_mpeg(self, _msg):
        alg = Crc(
            width=self.crc_width,
            poly=self.crc_poly,
            reflect_in=self.crc_reflect_in,
            xor_in=self.crc_xor_in,
            reflect_out=self.crc_reflect_out,
            xor_out=self.crc_xor_out,
            table_idx_width=8,
        )
        crc_int = alg.bit_by_bit(_msg)
        crc = struct.pack('>I', crc_int)
        return crc

    def gen_header(self, _pid):
        # pid is an integer
        # pid = PMT channel pid
        #       STT 1FFB
        #       VCT 1FFB
        #       PAT 0
        #       CAT 1
        # set the msg_counter for this pid
        if _pid not in self.msg_counter.keys():
            self.msg_counter[_pid] = 0

        sync = 0x47400000  # 1195376640   # 4740 0000
        pid_shifted = _pid << 8
        msg_int = sync | pid_shifted | (self.msg_counter[_pid] + 16)  # x10
        msg = struct.pack('>I', msg_int) + b'\x00'
        self.msg_counter[_pid] += 1
        if self.msg_counter[_pid] > 15:
            self.msg_counter[_pid] = 0
        return msg

    def gen_multiple_string_structure(self, _names):
        # Table 6.39 Multiple String Structure
        # event titles, long channel names, the ETT messages, and RRT text items
        # allows for upto 255 character strings
        # 8bit = array size
        # for each name
        #    3byte ISO_639_language_string = 'eng'
        #    1byte segments = normally 0x01
        #    for each segment
        #        1byte compression = 0x00 (not compression)
        #        1byte mode = 0x00 (used with unicode 2 byte letters, assume ASCII)
        #        1byte length in bytes = calculated
        #        string in byte format.  1 byte per character
        msg = utils.set_u8(len(_names))
        for name in _names:
            lang = self.gen_lang(b'eng')
            segment_len = utils.set_u8(1)
            compress_mode = utils.set_u16(0)
            name_bytes = utils.set_str(name.encode(), False)
            msg += lang + segment_len + compress_mode + name_bytes
        return msg

    def gen_channel_longnames(self, names):
        # Table 6.28 Extended Channel Name Descriptor
        # channel  name  for  the  virtual  channel  containing this descriptor
        # allows for upto 245 character strings
        # 8bit = tag = 0xA0
        # 8bit = description length
        # long_channel_name_text = gen_multiple_string_structure()
        long_name = self.gen_multiple_string_structure(names)
        return ATSC_EXTENDED_CHANNEL_DESCR_TAG + utils.set_u8(len(long_name)) + long_name

    def gen_vct_channel_descriptor(self, xxx):
        #    111111 static bits
        #    10bits description_length = long channel name length
        #       a list of descriptor()   possible descriptors listed in Table 6.25a

        # expected descriptors
        # A0 = channel long names
        # A1 = Service Location
        pass

    def gen_pid(self, _prog_number):
        # the PID is based on the program number and returns an integer (not bytes)
        # 30,40,50,60,130,140,150,160,230,...
        # Base_PID = prog_num << 4
        # Video Stream Element = Base_PID + 1 with the 12th bit set
        # Audio Stream Elements = Vide Stream PID + 4 with the 12th bit set, then +1 for each additional lang
        pid_lookup = [0x00, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80, 0x90,
                      0x130, 0x140, 0x150, 0x160, 0x170, 0x180, 0x190, 0x230, 0x240]
        return pid_lookup[_prog_number]

    def gen_lang(self, _name):
        return struct.pack('%ds' % (len(_name)), _name)

    def update_sdt_names(self, _video, _service_provider, _service_name):
        if _video.data is None:
            return
        i = 0
        video_len = len(_video.data)
        msg = None
        while True:
            if i + ATSC_MSG_LEN > video_len:
                break
            packet = _video.data[i:i + ATSC_MSG_LEN]
            program_fields = self.decode_ts_packet(packet)
            if program_fields is None:
                i += ATSC_MSG_LEN
                continue
            if program_fields['transport_error_indicator']:
                i += ATSC_MSG_LEN
                continue
            if program_fields['pid'] == 0x0011:
                descr = b'\x01' \
                        + utils.set_str(_service_provider, False) \
                        + utils.set_str(_service_name, False)
                descr = b'\x48' + utils.set_u8(len(descr)) + descr
                msg = packet[8:20] + utils.set_u8(len(descr)) + descr
                length = utils.set_u16(len(msg) + 4 + 0xF000)
                msg = ATSC_SERVICE_DESCR_TABLE_TAG + length + msg
                crc = self.gen_crc_mpeg(msg)
                msg = packet[:5] + msg + crc
                msg = msg.ljust(len(packet), b'\xFF')
                _video.data = b''.join([
                    _video.data[:i],
                    msg,
                    _video.data[i + ATSC_MSG_LEN:]
                ])
            i += ATSC_MSG_LEN
        if msg is None:
            self.logger.debug('Missing ATSC SDT Msg in stream, unable to update provider and service name')
        else:
            self.logger.debug('Updating ATSC SDT with service info {} {}' \
                              .format(_service_provider, _service_name))

    def gen_sld(self, _base_pid, _elements):
        # Table 6.29 Service Location Descriptor
        # Appears in each channel in the VCT
        # 8bit = tag = 0xA1
        # 8bit = description length
        # 3bits = 111 static bits
        # 13bits = PCR_PID = 0x1FFF or the program ID value found in the TS_prog_map
        # 8bits = number of elements
        # for each element
        #    8bits = stream_type = 0x02 (video stream) or 0x81 (audio stream)
        #    3bits = 111 static bits
        #    13bits = PCR_PID = (same as abovefor video stream) unique for audio
        #    8*3bytes = lang (spa, eng, mul, null for video stream
        #
        # element is an array of languages

        # the PID is based on the program number.
        # Base_PID = prog_num << 4
        # Video Stream Element = Base_PID + 1 with the 12th bit set
        # Audio Stream Elements = Vide Stream PID + 4 with the 12th bit set, then +1 for each additional lang

        elem_len = utils.set_u8(len(_elements) + 1)
        video_pid = utils.set_u16(_base_pid + 1 + 57344)  # E000
        stream_type = b'\x02'
        lang_0 = b'\x00\x00\x00'
        msg = stream_type + video_pid + lang_0
        stream_type = b'\x81'
        audio_pid_int = _base_pid + 3 + 57344  # E000 (starts at 0x34 and increments by 1)
        for lang in _elements:
            audio_pid_int += 1
            audio_pid = utils.set_u16(audio_pid_int)
            lang_msg = struct.pack('%ds' % (len(lang)),
                                   lang.encode())
            msg += stream_type + audio_pid + lang_msg
        msg = video_pid + elem_len + msg
        length = utils.set_u8(len(msg))
        return ATSC_SERVICE_LOCATION_DESCR_TAG + length + msg

    def gen_vct_channel(self, _tsid, _short_name, _channel):
        # Channel part of Table 6.4 Terrestrial Virtual Channel Table
        #    7*2byte characters short name = dict key
        #    1111 static bits
        #    10bits major channel number
        #    10bits minor channel number
        #    1byte modulation_mode = 0x04
        #    4bytes carrier_freq = 0
        #    2bytes channel_tsid = same as VCT TSID
        #    2bytes program number = index from 1 to n
        #    2bits ETM_location = 00 (no location)
        #    1bit access_control = 0
        #    1bit hidden = 0
        #    11 static bits
        #    1bit hide_guide = 0
        #    111 static bits
        #    6bits service_type = 000010
        #    2bytes source_id = index from 1 to n (same as prog_num)
        #    111111 static bits
        #    10bits description_length = long channel name length
        #       descriptor() = gen_extended_channel_descriptor(names)
        #    111111 static bits
        #    10bits additional_description_length = long channel name length = 0
        #       no additional descriptions are used

        # chnum_maj
        # chnum_min
        # prog_num
        # long_name
        u16name = b''
        short_name7 = _short_name.ljust(7, '\x00')

        for ch in short_name7:
            u16name += utils.set_u16(ord(ch))
        ch_num = _channel['chnum_maj'] << 10
        ch_num |= 15728640  # 0xf00000 static bits
        ch_num |= _channel['chnum_min']
        u3bch_num = utils.set_u32(ch_num)[1:]
        mod_mode = b'\x04'
        freq = b'\x00\x00\x00\x00'
        prog_num = utils.set_u16(_channel['prog_num'])
        pid = self.gen_pid(_channel['prog_num'])
        misc_bits = b'\x0d\xc2'  # 0000 1101 1100 0010
        source_id = prog_num
        descr = _channel['descr']
        descr_msg = b''
        for key in descr.keys():
            if key == 'long_names':
                descr_msg += self.gen_channel_longnames(descr[key])
            elif key == 'lang':
                descr_msg += self.gen_sld(pid, descr[key])
        descr_len = utils.set_u16(len(descr_msg) + 0xFC00)

        return u16name + u3bch_num + mod_mode + freq + _tsid + prog_num + misc_bits + \
            source_id + descr_len + descr_msg

    def gen_pat_channels(self, _channels):
        # for each section (sids):
        #    2bytes = program number (non-zero) 1..n
        #    3bits = 111 static bits
        #    13bits = multiples of 10 30,40,50,60,130,140,150,160,230,...
        msg = b''
        for i in range(1, len(_channels) + 1):
            pid = utils.set_u16(self.gen_pid(i) + 57344)  # E000
            msg += utils.set_u16(i) + pid
        return msg

    def gen_pat(self, _mux_stream):
        # Table Program Association Table : MPEG-2 protocol
        # 1byte table_id = 0x00
        # 1011 static bits
        # 12bits length including crc
        # 2bytes = tsid  (0000 11xx xxxx xxxx)
        # 2bits = 11 static bits
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1byte last_section_number = 0 (only one section)
        # gen_pat_channels()
        # crc
        tsid = _mux_stream['tsid']
        ver_sect = b'\xc3\x00\x00'
        channels_len = utils.set_u8(len(_mux_stream['channels']))
        for i in range(len(_mux_stream['channels'])):
            pid = self.gen_pid(i)
        msg = tsid + ver_sect + self.gen_pat_channels(_mux_stream['channels'])
        length = utils.set_u16(len(msg) + 4 + 0xB000)
        msg = MPEG2_PROGRAM_ASSOCIATION_TABLE_TAG + length + msg
        crc = self.gen_crc_mpeg(msg)
        msg = self.gen_header(0) + msg + crc
        return self.format_video_packets([msg])

    def gen_vct(self, _mux_stream):
        # Table 6.4 Terrestrial Virtual Channel Table
        # 1byte table_id = 0xc8
        # 1111 static bits
        # 12bits length including crc
        # 2bytes TSID (transport stream id) = 0x0b21 (how is this generated?)
        # 11 static bits
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1bytes last_section_number = 0 (only one section)
        # 1byte protocol_version = 0
        # 1byte number of channels
        #    gen_vct_channel(channel)
        # CRC_32
        msg = b''
        tsid = _mux_stream['tsid']
        ver_sect_last_sect_proto = b'\xc3\x00\x00\x00'
        channels_len = utils.set_u8(len(_mux_stream['channels']))
        for short_name in _mux_stream['channels'].keys():
            msg += self.gen_vct_channel(tsid, short_name, _mux_stream['channels'][short_name])
        extra_empty_descr = b'\xfc\x00'
        msg = tsid + ver_sect_last_sect_proto + channels_len + msg + extra_empty_descr
        length = utils.set_u16(len(msg) + 4 + 0xF000)

        msg = ATSC_VIRTUAL_CHANNEL_TABLE_TAG + length + msg
        crc = self.gen_crc_mpeg(msg)
        msg = self.gen_header(0x1ffb) + msg + crc

        # channels is a dict with the key being the primary channel name (short_name)
        return self.format_video_packets([msg])

    def gen_stt(self):
        # Table 6.1 System Time Table
        # 1byte table_id = 0xcd
        # 1111 static bits
        # 12bits length including crc
        # 2bytes table id extension = 0x0000
        # 2bits = 11 static bits
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1byte last_section_number = 0 (only one section)
        # 1byte protocol_version = 0
        # 4bytes system time = time since 1980 (GPS)
        # 1byte GPS_UTC_offset = 12 (last checked 2021)
        # 2bytes daylight_saving = 0x60
        #  1bit ds_status 
        #  2bits 11 static bits
        #  5bits DS day of month
        #  8bits DS hour
        # CRC_32

        #         475f fb17 00cd f011 0000 c100 0000  ..G_............
        # 0x01b0:  4d3c e809 1060 00f3 30ca 76
        # 1295837193
        table_id_ext = b'\x00\x00'
        ver_sect_proto = b'\xc1\x00\x00\x00'

        time_gps = datetime.datetime.utcnow() - datetime.datetime(1980, 1, 6) \
                   - datetime.timedelta(seconds=LEAP_SECONDS_2021 - LEAP_SECONDS_1980)
        time_gps_sec = int(time_gps.total_seconds())
        system_time = utils.set_u32(time_gps_sec)
        delta_time = utils.set_u8(LEAP_SECONDS_2021 - LEAP_SECONDS_1980)
        daylight_savings = b'\x60'

        msg = table_id_ext + ver_sect_proto + system_time + \
              delta_time + daylight_savings + b'\x00'
        length = utils.set_u16(len(msg) + 4 + 0xF000)
        msg = MPEG2_PROGRAM_SYSTEM_TIME_TABLE_TAG + length + msg
        crc = self.gen_crc_mpeg(msg)
        msg = self.gen_header(0x1ffb) + msg + crc
        return self.format_video_packets([msg])

    def gen_pmt(self, _channels):
        # Table Program Map Table : MPEG-2 protocol
        # 
        # DATA EXAMPLE
        # 0001 b009 ffff c300 00d5 dcfb 4c
        # 1byte table_id = 0x02
        # 1011 static bits
        # 12bits length including crc
        # 2bytes = program number (like 6)
        # 2bits = 11 static bits
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1byte last_section_number = 0 (only one section)
        # 3bits = 111 static bits
        # 13bits = PCR_PID (like for prog_num 3 = 61. seems to always end in a 1)
        # 4bits = 1111 static bits
        # 12bits = program_info_length
        #    for loop of descriptors
        #        05 name of the channel (GA94)
        #

        msgs = []
        prog_num_int = 0
        for short_name in _channels.keys():
            prog_num_int += 1
            prog_num_bytes = utils.set_u16(prog_num_int)
            ver_sect = b'\xc1\x00\x00'
            base_pid_int = self.gen_pid(prog_num_int)
            pid_video_int = base_pid_int + 1
            pid_video = utils.set_u16(pid_video_int + 0xE000)
            pid_audio_int = pid_video_int + 3
            pid_audio = utils.set_u16(pid_audio_int + 0xE000)
            descr_prog = b'\xf0\x00'
            descr_video = b'\x02' + pid_video + b'\xF0\x00'
            descr_audio = b'\x81' + pid_audio + b'\xF0\x00'
            msg = prog_num_bytes + ver_sect + pid_video + descr_prog + descr_video + descr_audio
            length = utils.set_u16(len(msg) + 4 + 0xB000)
            msg = MPEG2_PROGRAM_MAP_TABLE_TAG + length + msg
            crc = self.gen_crc_mpeg(msg)
            msgs.append(self.gen_header(base_pid_int) + msg + crc)
        return [self.format_video_packets(msgs)]

    def gen_mgt(self, _mux_stream):
        # Table 6.2 Master Guide Table
        # 1byte table_id = 0xc7
        # 1111 static bits
        # 12bits length including crc
        # 16bits 0x0000 static bits
        # 2bits = 11 = static bits
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1byte last_section_number = 0 (only one section)
        # 1byte protocol_version = 0
        # 2bytes number of tables

        msg = ATSC_MASTER_GUIDE_TABLE_TAG
        return msg

    def gen_cat(self):
        # Table Conditional Access Table : MPEG-2 protocol
        # 
        # DATA EXAMPLE
        # 0001 b009 ffff c300 00d5 dcfb 4c
        # 1byte table_id = 0x01
        # 1011 static bits
        # 12bits length including crc
        # 18bits 1111 1111 1111 1111 11
        # 5bits version_no = 1
        # 1bit current_next_indicator = 1
        # 1byte section_number = 0 (only one section)
        # 1byte last_section_number = 0 (only one section)
        # c10000 (5) c30000 (2,3,4,5,6)  d50000 (7) c50000 (3) d30000 (5)
        # c70000 (3) dd0000 (4)
        # for each section (sids):
        #    2bytes = program number (non-zero)
        #    3bits = 111 static bits
        #    13bits = multiples of 10
        #    0001 e0 30
        #    0002 e0 40
        #    0003 e0 50
        #    0004 e0 60
        # crc
        # NOTE: all transmissions had a zero sections transmission
        # search 0x0020.*0001  ...
        return b'\x00\x01\xb0\x09\xff\xff\xc3\x00\x00\xd5\xdc\xfb\x4c'

    def update_continuity_counter(self, section):
        pid = self.get_pid(section)
        if pid is None:
            return section

        if pid not in self.msg_counter.keys():
            self.msg_counter[pid] = 0

        s_int = section[3]
        s_top = s_int & 0xf0

        s_int = s_top + self.msg_counter[pid]
        sect_ba = bytearray(section)
        sect_ba[3] = s_int
        sect_bytes = bytes(sect_ba)

        self.msg_counter[pid] += 1
        if self.msg_counter[pid] > 15:
            self.msg_counter[pid] = 0

        return sect_bytes


    def format_video_packets(self, _msgs=None):
        # atsc packets are 1316 in length with 7 188 sections
        # each section has a 471f ff10 00 when no data is present

        # finally the controls and msg counter byte is added (10) no msg counter
        # for continuation it had 471f fb1b 0000 previously 475f fb1a
        # 471f fb15 00  475f fb14 00 (c8 or c7)
        # 
        # pid = PMT channel pid
        #       STT 1FFB
        #       VCT 1FFB
        #       PAT 0
        #       CAT 1
        # 7 sections per packet
        sections = [
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
            self.update_continuity_counter(self.atsc_blank_section),
        ]

        if _msgs is None:
            return b''.join(sections)

        # for now assume the msgs are less than 1316
        if len(_msgs) > 7:
            self.logger.error('ATSC: TOO MANY MESSAGES={}'.format(len(_msgs)))
            return None
        for i in range(len(_msgs)):
            if len(_msgs[i]) > ATSC_MSG_LEN:
                self.logger.error('ATSC: MESSAGE LENGTH TOO LONG={}'.format(len(_msgs[i])))
                return None
            else:
                sections[i] = self.update_continuity_counter(_msgs[i].ljust(ATSC_MSG_LEN, b'\xff'))

        return b''.join(sections)
        # TBD need to handle large msg and more than 7 msgs

    def extract_psip(self, _video_data):
        packet_list = []
        if _video_data is None:
            return
        i = 0
        video_len = len(_video_data)
        prev_pid = -1
        pmt_pids = None
        pat_found = False
        pmt_found = False
        seg_counter = 0

        while True:
            if i + ATSC_MSG_LEN > video_len:
                break
            packet = _video_data[i:i + ATSC_MSG_LEN]
            i += ATSC_MSG_LEN
            program_fields = self.decode_ts_packet(packet)

            seg_counter += 1
            if seg_counter > 7:
                # self.logger.debug('###### SENDING BACK {} PACKETS'.format(len(packet_list)))
                break

            if program_fields is None:
                continue
            if program_fields['transport_error_indicator']:
                continue

            # SDT: 17, PAT: 0, Private data: 4096 (audio/video meta)
            if program_fields['pid'] == 0 \
                    or program_fields['pid'] == 4096:
                packet_list.append(packet)

                seg_counter += 1
                if seg_counter > 7:
                    # self.logger.debug('###### SENDING BACK {} PACKETS'.format(len(packet_list)))
                    break

                continue


            if program_fields['pid'] == 0x0000:
                pmt_pids = self.decode_pat(program_fields['payload'])
                # self.logger.debug('###### EXPECTED PMT PIDS: {}'.format(pmt_pids))
                if not pat_found:
                    packet_list.append(packet)
                    pat_found = True
            #if pmt_pids and program_fields['pid'] in pmt_pids.keys():
            #    program = pmt_pids[program_fields['pid']]
            #    self.decode_pmt(program_fields['pid'], program, program_fields['payload'])
            #    if not pmt_found:
            #        # self.logger.debug('###### FOUND PMT PID: {}'.format(program_fields['pid']))
            #        packet_list.append(packet)
            #        pmt_found = True
            #    continue
            #elif program_fields['pid'] == 0x1ffb:
            #    self.logger.info('Packet Table indicator 0x1ffb, not implemented {}'.format(i))
            #    continue
            # elif program_fields['pid'] == 0x0011:
            #    self.logger.info('Service Description Table (SDT) 0x0011, not implemented {}'.format(i))
            #    continue
            # elif program_fields['pid'] == 0x0000 or \
            #        program_fields['pid'] == 0x0100 or \
            #        program_fields['pid'] == 0x0101:
            #    continue
            # else:
            #    self.logger.info('Unknown PID {}'.format(program_fields['pid']))                
            prev_pid = program_fields['pid']
        return packet_list

    def sync_audio_video(self, _video_data):
        """
        Trims the audio or video to sync the PTS for both
        and return the video data with the removed parts
        """
        packet_list = []
        if _video_data is None:
            return
        i = 0
        video_len = len(_video_data)
        prev_pid = -1
        pmt_pids = None
        pat_found = False
        pmt_found = False
        seg_counter = 0

        # print('writing out segment')
        # f = open('/tmp/data/segment.ts', 'wb')
        # f.write(_video_data)
        # f.close()

        while True:
            if i + ATSC_MSG_LEN > video_len:
                break
            packet = _video_data[i:i + ATSC_MSG_LEN]
            i += ATSC_MSG_LEN
            program_fields = self.decode_ts_packet(packet)

            seg_counter += 1
            if seg_counter > 7:
                # self.logger.debug('###### SENDING BACK {} PACKETS'.format(len(packet_list)))
                break
            else:
                packet_list.append(packet)
                continue

            if program_fields is None:
                continue
            if program_fields['transport_error_indicator']:
                continue

            if program_fields['pid'] == 0x0000:
                pmt_pids = self.decode_pat(program_fields['payload'])
                # self.logger.debug('###### EXPECTED PMT PIDS: {}'.format(pmt_pids))
                if not pat_found:
                    packet_list.append(packet)
                    pat_found = True
            if pmt_pids and program_fields['pid'] in pmt_pids.keys():
                program = pmt_pids[program_fields['pid']]
                self.decode_pmt(program_fields['pid'], program, program_fields['payload'])
                if not pmt_found:
                    # self.logger.debug('###### FOUND PMT PID: {}'.format(program_fields['pid']))
                    packet_list.append(packet)
                    pmt_found = True
                continue
            elif program_fields['pid'] == 0x1ffb:
                self.logger.info('Packet Table indicator 0x1ffb, not implemented {}'.format(i))
                continue
            # elif program_fields['pid'] == 0x0011:
            #    self.logger.info('Service Description Table (SDT) 0x0011, not implemented {}'.format(i))
            #    continue
            # elif program_fields['pid'] == 0x0000 or \
            #        program_fields['pid'] == 0x0100 or \
            #        program_fields['pid'] == 0x0101:
            #    continue
            # else:
            #    self.logger.info('Unknown PID {}'.format(program_fields['pid']))                
            prev_pid = program_fields['pid']
        return packet_list


    def get_pid(self, _packet_188):
        word = struct.unpack('!I', _packet_188[0:4])[0]
        sync = (word & 0xff000000) >> 24
        if sync != 0x47:
            return None

        # Packet Identifier, describing the payload data.
        pid = (word & 0x1fff00) >> 8
        return pid

    def decode_ts_packet(self, _packet_188):
        fields = {}
        word = struct.unpack('!I', _packet_188[0:4])[0]
        sync = (word & 0xff000000) >> 24
        if sync != 0x47:
            return None

        fields['transport_error_indicator'] = (word & 0x800000) != 0
        # Set when a demodulator can't correct errors from FEC data; indicating the packet is corrupt
        # print transport_error_indicator

        # Set when a PES, PSI, or DVB-MIP packet begins immediately following the header.
        fields['payload_unit_start_indicator'] = (word & 0x400000) != 0

        # "Set when the current packet has a higher priority than other packets with the same PID.
        fields['transport_priority'] = (word & 0x200000) != 0

        # Packet Identifier, describing the payload data.
        fields['pid'] = (word & 0x1fff00) >> 8
        # '00' = Not scrambled.
        # For DVB-CSA and ATSC DES only:[8]
        # '01' (0x40) = Reserved for future use
        # '10' (0x80) = Scrambled with even key
        # '11' (0xC0) = Scrambled with odd key
        fields['scrambling_control'] = (word & 0xc0) >> 6

        # 01 – no adaptation field, payload only,
        # 10 – adaptation field only, no payload,
        # 11 – adaptation field followed by payload,
        # 00 - RESERVED for future use [9]
        fields['adaptation_field_control'] = (word & 0x30) >> 4

        if fields['adaptation_field_control'] == 1:
            has_adapt = False
            has_payload = True
        elif fields['adaptation_field_control'] == 2:
            has_adapt = True
            has_payload = False
        elif fields['adaptation_field_control'] == 3:
            has_adapt = True
            has_payload = True
        else:
            # 00 - RESERVED for future use
            # hence tstools "### Packet PID 14ae has adaptation field control = 0
            #    which is a reserved value (no payload, no adaptation field)"
            # just assume payload, don't spam, and mark it corrupted
            has_adapt = False
            has_payload = True
            fields['corrupted_adaption_control_field'] = True

        # Sequence number of payload packets (0x00 to 0x0F) within each stream (except PID 8191)
        # Incremented per-PID, only when a payload flag is set.
        fields['cont_counter'] = word & 0xf

        payload_start = 5
        if has_adapt:
            adapt_length = struct.unpack('b', bytes([_packet_188[5]]))[0]
            if 6 + adapt_length > len(_packet_188):
                return None

            fields['adapt'] = _packet_188[6:6 + adapt_length]
            payload_start = 6 + adapt_length

        if has_payload:
            fields['payload'] = _packet_188[payload_start:]
        else:
            # No payload here according to the bitfields - save it anyways
            extra = _packet_188[payload_start:]
            if len(extra) != 0:
                fields['corrupt_payload'] = extra

        return fields

    def decode_pmt(self, pid, program, payload):
        t = binascii.b2a_hex(payload)
        if t not in self.type_strings:
            self.type_strings.append(t)

        pcr_pid = struct.unpack("!H", payload[8:10])[0]
        reserved = (pcr_pid & 0xe000) >> 13
        pcr_pid &= 0x1fff
        desc1 = payload[12:]
        # self.logger.debug('###### PMT DESCR {} {}'.format(pcr_pid, desc1))
        # descriptors = decode_descriptors(desc1)

    def decode_pat(self, payload):
        t = binascii.b2a_hex(payload)
        if t not in self.type_strings:
            self.type_strings.append(t)

        # http://www.etherguidesystems.com/Help/SDOs/MPEG/Syntax/TableSections/Pat.aspx

        section_length = (payload[1] & 0xf << 8) | payload[2]  # 12-bit field
        program_map_pids = {}

        # after extra fields (transport_stream_id to last_section_num, by size, minus CRC-32 at end
        program_count = (section_length - 5) / 4 - 1

        if section_length > 20:
            return program_map_pids

        for i in range(0, int(program_count)):
            at = 8 + (i * 4)  # skip headers, just get to the program numbers table
            program_number = struct.unpack("!H", payload[at:at + 2])[0]
            if at + 2 > len(payload):
                break
            program_map_pid = struct.unpack("!H", payload[at + 2:at + 2 + 2])[0]

            # the pid is only 13 bits, upper 3 bits of this field are 'reserved' (I see 0b111)
            reserved = (program_map_pid & 0xe000) >> 13
            program_map_pid &= 0x1fff

            program_map_pids[program_map_pid] = program_number
            i += 1
        return program_map_pids