srs/trunk/3rdparty/srs-bench/vendor/github.com/yapingcat/gomedia/mpeg2/ts-proto.go

package mpeg2

import (
    "encoding/binary"
    "errors"
    "fmt"
    "os"

    "github.com/yapingcat/gomedia/codec"
)

//PID
type TS_PID int

const (
    TS_PID_PAT TS_PID = 0x0000
    TS_PID_CAT
    TS_PID_TSDT
    TS_PID_IPMP
    TS_PID_Nil = 0x1FFFF
)

//Table id
type PAT_TID int

const (
    TS_TID_PAS       PAT_TID = 0x00 // program_association_section
    TS_TID_CAS               = 0x01 // conditional_access_section(CA_section)
    TS_TID_PMS               = 0x02 // TS_program_map_section
    TS_TID_SDS               = 0x03 //TS_description_section
    TS_TID_FORBIDDEN PAT_TID = 0xFF
)

type TS_STREAM_TYPE int

const (
    TS_STREAM_AAC  TS_STREAM_TYPE = 0x0F
    TS_STREAM_H264 TS_STREAM_TYPE = 0x1B
    TS_STREAM_H265 TS_STREAM_TYPE = 0x24
)

const (
    TS_PAKCET_SIZE = 188
)

type Display interface {
    PrettyPrint(file *os.File)
}

// transport_packet(){
//     sync_byte                                                                                         8                      bslbf
//     transport_error_indicator                                                                         1                      bslbf
//     payload_unit_start_indicator                                                                     1                      bslbf
//     transport_priority                                                                                 1                      bslbf
//     PID                                                                                             13                     uimsbf
//     transport_scrambling_control                                                                     2                      bslbf
//     adaptation_field_control                                                                        2                      bslbf
//     continuity_counter                                                                                 4                      uimsbf
//     if(adaptation_field_control = = '10' || adaptation_field_control = = '11'){
//          adaptation_field()
//      }
//      if(adaptation_field_control = = '01' || adaptation_field_control = = '11') {
//          for (i = 0; i < N; i++){
//              data_byte                                                                                 8                      bslbf
//          }
//     }
// }

type TSPacket struct {
    Transport_error_indicator    uint8
    Payload_unit_start_indicator uint8
    Transport_priority           uint8
    PID                          uint16
    Transport_scrambling_control uint8
    Adaptation_field_control     uint8
    Continuity_counter           uint8
    Field                        *Adaptation_field
    Payload                      interface{}
}

func (pkg *TSPacket) PrettyPrint(file *os.File) {
    file.WriteString(fmt.Sprintf("Transport_error_indicator:%d\n", pkg.Transport_error_indicator))
    file.WriteString(fmt.Sprintf("Payload_unit_start_indicator:%d\n", pkg.Payload_unit_start_indicator))
    file.WriteString(fmt.Sprintf("Transport_priority:%d\n", pkg.Transport_priority))
    file.WriteString(fmt.Sprintf("PID:%d\n", pkg.PID))
    file.WriteString(fmt.Sprintf("Transport_scrambling_control:%d\n", pkg.Transport_scrambling_control))
    file.WriteString(fmt.Sprintf("Adaptation_field_control:%d\n", pkg.Adaptation_field_control))
    file.WriteString(fmt.Sprintf("Continuity_counter:%d\n", pkg.Continuity_counter))
}

func (pkg *TSPacket) EncodeHeader(bsw *codec.BitStreamWriter) {
    bsw.PutByte(0x47)
    bsw.PutUint8(pkg.Transport_error_indicator, 1)
    bsw.PutUint8(pkg.Payload_unit_start_indicator, 1)
    bsw.PutUint8(pkg.Transport_priority, 1)
    bsw.PutUint16(pkg.PID, 13)
    bsw.PutUint8(pkg.Transport_scrambling_control, 2)
    bsw.PutUint8(pkg.Adaptation_field_control, 2)
    bsw.PutUint8(pkg.Continuity_counter, 4)
    if pkg.Field != nil && (pkg.Adaptation_field_control&0x02) != 0 {
        pkg.Field.Encode(bsw)
    }
}

func (pkg *TSPacket) DecodeHeader(bs *codec.BitStream) error {
    sync_byte := bs.Uint8(8)
    if sync_byte != 0x47 {
        return errors.New("ts packet must start with 0x47")
    }
    pkg.Transport_error_indicator = bs.GetBit()
    pkg.Payload_unit_start_indicator = bs.GetBit()
    pkg.Transport_priority = bs.GetBit()
    pkg.PID = bs.Uint16(13)
    pkg.Transport_scrambling_control = bs.Uint8(2)
    pkg.Adaptation_field_control = bs.Uint8(2)
    pkg.Continuity_counter = bs.Uint8(4)
    if pkg.Adaptation_field_control == 0x02 || pkg.Adaptation_field_control == 0x03 {
        if pkg.Field == nil {
            pkg.Field = new(Adaptation_field)
        }
        err := pkg.Field.Decode(bs)
        if err != nil {
            return err
        }
    }
    return nil
}

//
// adaptation_field() {
// adaptation_field_length
// if (adaptation_field_length > 0) {
//     discontinuity_indicator
//     random_access_indicator
//     elementary_stream_priority_indicator
//     PCR_flag
//     OPCR_flag
//     splicing_point_flag
//     transport_private_data_flag
//     adaptation_field_extension_flag
//     if (PCR_flag == '1') {
//         program_clock_reference_base
//         reserved
//         program_clock_reference_extension
//     }
//     if (OPCR_flag == '1') {
//         original_program_clock_reference_base
//         reserved
//         original_program_clock_reference_extension
//     }
//     if (splicing_point_flag == '1') {
//         splice_countdown
//     }
//     if (transport_private_data_flag == '1') {
//         transport_private_data_length
//         for (i = 0; i < transport_private_data_length; i++) {
//             private_data_byte
//         }
//     }
//     if (adaptation_field_extension_flag == '1') {
//         adaptation_field_extension_length
//         ltw_flag piecewise_rate_flag
//         seamless_splice_flag
//         reserved
//         if (ltw_flag == '1') {
//             ltw_valid_flag
//             ltw_offset
//         }
//         if (piecewise_rate_flag == '1') {
//             reserved
//             piecewise_rate
//         }
//         if (seamless_splice_flag == '1') {
//             splice_type
//             DTS_next_AU[32..30]
//             marker_bit
//             DTS_next_AU[29..15]
//             marker_bit
//             DTS_next_AU[14..0]
//             marker_bit 1
//         }
//         for (i = 0; i < N; i++) {
//             reserved 8
//         }
//     }
//     for (i = 0; i < N; i++) {
//         stuffing_byte 8
//     }
// }

type Adaptation_field struct {
    SingleStuffingByte                         bool   // The value 0 is for inserting a single stuffing byte in a Transport Stream packet
    Adaptation_field_length                    uint8  //8   uimsbf
    Discontinuity_indicator                    uint8  //1   bslbf
    Random_access_indicator                    uint8  //1   bslbf
    Elementary_stream_priority_indicator       uint8  //1   bslbf
    PCR_flag                                   uint8  //1   bslbf
    OPCR_flag                                  uint8  //1   bslbf
    Splicing_point_flag                        uint8  //1   bslbf
    Transport_private_data_flag                uint8  //1   bslbf
    Adaptation_field_extension_flag            uint8  //1   bslbf
    Program_clock_reference_base               uint64 //33  uimsbf
    Program_clock_reference_extension          uint16 //9   uimsbf
    Original_program_clock_reference_base      uint64 //33  uimsbf
    Original_program_clock_reference_extension uint16 //9   uimsbf
    Splice_countdown                           uint8  //8   uimsbf
    Transport_private_data_length              uint8  //8   uimsbf
    Adaptation_field_extension_length          uint8  //8   uimsbf
    Ltw_flag                                   uint8  //1   bslbf
    Piecewise_rate_flag                        uint8  //1   bslbf
    Seamless_splice_flag                       uint8  //1   bslbf
    Ltw_valid_flag                             uint8  //1   bslbf
    Ltw_offset                                 uint16 //15  uimsbf
    Piecewise_rate                             uint32 //22  uimsbf
    Splice_type                                uint8  //4   uimsbf
    DTS_next_AU                                uint64
    Stuffing_byte                              uint8
}

func (adaptation *Adaptation_field) PrettyPrint(file *os.File) {
    file.WriteString(fmt.Sprintf("Adaptation_field_length:%d\n", adaptation.Adaptation_field_length))
    file.WriteString(fmt.Sprintf("Discontinuity_indicator:%d\n", adaptation.Discontinuity_indicator))
    file.WriteString(fmt.Sprintf("Random_access_indicator:%d\n", adaptation.Random_access_indicator))
    file.WriteString(fmt.Sprintf("Elementary_stream_priority_indicator:%d\n", adaptation.Elementary_stream_priority_indicator))
    file.WriteString(fmt.Sprintf("PCR_flag:%d\n", adaptation.PCR_flag))
    file.WriteString(fmt.Sprintf("OPCR_flag:%d\n", adaptation.OPCR_flag))
    file.WriteString(fmt.Sprintf("Splicing_point_flag:%d\n", adaptation.Splicing_point_flag))
    file.WriteString(fmt.Sprintf("Transport_private_data_flag:%d\n", adaptation.Transport_private_data_flag))
    file.WriteString(fmt.Sprintf("Adaptation_field_extension_flag:%d\n", adaptation.Adaptation_field_extension_flag))
    if adaptation.PCR_flag == 1 {
        file.WriteString(fmt.Sprintf("Program_clock_reference_base:%d\n", adaptation.Program_clock_reference_base))
        file.WriteString(fmt.Sprintf("Program_clock_reference_extension:%d\n", adaptation.Program_clock_reference_extension))
    }
    if adaptation.OPCR_flag == 1 {
        file.WriteString(fmt.Sprintf("Original_program_clock_reference_base:%d\n", adaptation.Original_program_clock_reference_base))
        file.WriteString(fmt.Sprintf("Original_program_clock_reference_extension:%d\n", adaptation.Original_program_clock_reference_extension))
    }
    if adaptation.Splicing_point_flag == 1 {
        file.WriteString(fmt.Sprintf("Splice_countdown:%d\n", adaptation.Splice_countdown))
    }
    if adaptation.Transport_private_data_flag == 1 {
        file.WriteString(fmt.Sprintf("Transport_private_data_length:%d\n", adaptation.Transport_private_data_length))
    }
    if adaptation.Adaptation_field_extension_flag == 1 {
        file.WriteString(fmt.Sprintf("Adaptation_field_extension_length:%d\n", adaptation.Adaptation_field_extension_length))
        file.WriteString(fmt.Sprintf("Ltw_flag:%d\n", adaptation.Ltw_flag))
        file.WriteString(fmt.Sprintf("Piecewise_rate_flag:%d\n", adaptation.Piecewise_rate_flag))
        file.WriteString(fmt.Sprintf("Seamless_splice_flag:%d\n", adaptation.Seamless_splice_flag))
        if adaptation.Ltw_flag == 1 {
            file.WriteString(fmt.Sprintf("Ltw_valid_flag:%d\n", adaptation.Ltw_valid_flag))
            file.WriteString(fmt.Sprintf("Ltw_offset:%d\n", adaptation.Ltw_offset))
        }
        if adaptation.Piecewise_rate_flag == 1 {
            file.WriteString(fmt.Sprintf("Piecewise_rate:%d\n", adaptation.Piecewise_rate))
        }
        if adaptation.Seamless_splice_flag == 1 {
            file.WriteString(fmt.Sprintf("Splice_type:%d\n", adaptation.Splice_type))
            file.WriteString(fmt.Sprintf("DTS_next_AU:%d\n", adaptation.DTS_next_AU))
        }
    }
}

func (adaptation *Adaptation_field) Encode(bsw *codec.BitStreamWriter) {
    loc := bsw.ByteOffset()
    bsw.PutUint8(adaptation.Adaptation_field_length, 8)
    if adaptation.SingleStuffingByte {
        return
    }
    bsw.Markdot()
    bsw.PutUint8(adaptation.Discontinuity_indicator, 1)
    bsw.PutUint8(adaptation.Random_access_indicator, 1)
    bsw.PutUint8(adaptation.Elementary_stream_priority_indicator, 1)
    bsw.PutUint8(adaptation.PCR_flag, 1)
    bsw.PutUint8(adaptation.OPCR_flag, 1)
    bsw.PutUint8(adaptation.Splicing_point_flag, 1)
    bsw.PutUint8(0 /*adaptation.Transport_private_data_flag*/, 1)
    bsw.PutUint8(0 /*adaptation.Adaptation_field_extension_flag*/, 1)
    if adaptation.PCR_flag == 1 {
        bsw.PutUint64(adaptation.Program_clock_reference_base, 33)
        bsw.PutUint8(0, 6)
        bsw.PutUint16(adaptation.Program_clock_reference_extension, 9)
    }
    if adaptation.OPCR_flag == 1 {
        bsw.PutUint64(adaptation.Original_program_clock_reference_base, 33)
        bsw.PutUint8(0, 6)
        bsw.PutUint16(adaptation.Original_program_clock_reference_extension, 9)
    }
    if adaptation.Splicing_point_flag == 1 {
        bsw.PutUint8(adaptation.Splice_countdown, 8)
    }
    //TODO
    // if adaptation.Transport_private_data_flag == 0 {
    // }
    // if adaptation.Adaptation_field_extension_flag == 0 {
    // }
    adaptation.Adaptation_field_length = uint8(bsw.DistanceFromMarkDot() / 8)
    bsw.PutRepetValue(0xff, int(adaptation.Stuffing_byte))
    adaptation.Adaptation_field_length += adaptation.Stuffing_byte
    bsw.SetByte(adaptation.Adaptation_field_length, loc)
}

func (adaptation *Adaptation_field) Decode(bs *codec.BitStream) error {
    if bs.RemainBytes() < 1 {
        return errors.New("len of data < 1 byte")
    }
    adaptation.Adaptation_field_length = bs.Uint8(8)
    startoffset := bs.ByteOffset()
    //fmt.Printf("Adaptation_field_length=%d\n", adaptation.Adaptation_field_length)
    if bs.RemainBytes() < int(adaptation.Adaptation_field_length) {
        return errors.New("len of data < Adaptation_field_length")
    }
    if adaptation.Adaptation_field_length == 0 {
        return nil
    }
    adaptation.Discontinuity_indicator = bs.GetBit()
    adaptation.Random_access_indicator = bs.GetBit()
    adaptation.Elementary_stream_priority_indicator = bs.GetBit()
    adaptation.PCR_flag = bs.GetBit()
    adaptation.OPCR_flag = bs.GetBit()
    adaptation.Splicing_point_flag = bs.GetBit()
    adaptation.Transport_private_data_flag = bs.GetBit()
    adaptation.Adaptation_field_extension_flag = bs.GetBit()
    if adaptation.PCR_flag == 1 {
        adaptation.Program_clock_reference_base = bs.GetBits(33)
        bs.SkipBits(6)
        adaptation.Program_clock_reference_extension = uint16(bs.GetBits(9))
    }
    if adaptation.OPCR_flag == 1 {
        adaptation.Original_program_clock_reference_base = bs.GetBits(33)
        bs.SkipBits(6)
        adaptation.Original_program_clock_reference_extension = uint16(bs.GetBits(9))
    }
    if adaptation.Splicing_point_flag == 1 {
        adaptation.Splice_countdown = bs.Uint8(8)
    }
    if adaptation.Transport_private_data_flag == 1 {
        adaptation.Transport_private_data_length = bs.Uint8(8)
        bs.SkipBits(8 * int(adaptation.Transport_private_data_length))
    }
    if adaptation.Adaptation_field_extension_flag == 1 {
        adaptation.Adaptation_field_extension_length = bs.Uint8(8)
        bs.Markdot()
        adaptation.Ltw_flag = bs.GetBit()
        adaptation.Piecewise_rate_flag = bs.GetBit()
        adaptation.Seamless_splice_flag = bs.GetBit()
        bs.SkipBits(5)
        if adaptation.Ltw_flag == 1 {
            adaptation.Ltw_valid_flag = bs.GetBit()
            adaptation.Ltw_offset = uint16(bs.GetBits(15))
        }
        if adaptation.Piecewise_rate_flag == 1 {
            bs.SkipBits(2)
            adaptation.Piecewise_rate = uint32(bs.GetBits(22))
        }
        if adaptation.Seamless_splice_flag == 1 {
            adaptation.Splice_type = uint8(bs.GetBits(4))
            adaptation.DTS_next_AU = bs.GetBits(3)
            bs.SkipBits(1)
            adaptation.DTS_next_AU = adaptation.DTS_next_AU<<15 | bs.GetBits(15)
            bs.SkipBits(1)
            adaptation.DTS_next_AU = adaptation.DTS_next_AU<<15 | bs.GetBits(15)
            bs.SkipBits(1)
        }
        bitscount := bs.DistanceFromMarkDot()
        if bitscount%8 > 0 {
            panic("maybe parser ts file failed")
        }
        bs.SkipBits(int(adaptation.Adaptation_field_extension_length*8 - uint8(bitscount)))
    }
    endoffset := bs.ByteOffset()
    bs.SkipBits((int(adaptation.Adaptation_field_length) - (endoffset - startoffset)) * 8)
    return nil
}

type PmtPair struct {
    Program_number uint16
    PID            uint16
}

type Pat struct {
    Table_id                 uint8  //8  uimsbf
    Section_syntax_indicator uint8  //1  bslbf
    Section_length           uint16 //12 uimsbf
    Transport_stream_id      uint16 //16 uimsbf
    Version_number           uint8  //5  uimsbf
    Current_next_indicator   uint8  //1  bslbf
    Section_number           uint8  //8  uimsbf
    Last_section_number      uint8  //8  uimsbf
    Pmts                     []PmtPair
}

func NewPat() *Pat {
    return &Pat{
        Table_id: uint8(TS_TID_PAS),
        Pmts:     make([]PmtPair, 0, 8),
    }
}

func (pat *Pat) PrettyPrint(file *os.File) {
    file.WriteString(fmt.Sprintf("Table id:%d\n", pat.Table_id))
    file.WriteString(fmt.Sprintf("Section_syntax_indicator:%d\n", pat.Section_syntax_indicator))
    file.WriteString(fmt.Sprintf("Section_length:%d\n", pat.Section_length))
    file.WriteString(fmt.Sprintf("Transport_stream_id:%d\n", pat.Transport_stream_id))
    file.WriteString(fmt.Sprintf("Version_number:%d\n", pat.Version_number))
    file.WriteString(fmt.Sprintf("Current_next_indicator:%d\n", pat.Current_next_indicator))
    file.WriteString(fmt.Sprintf("Section_number:%d\n", pat.Section_number))
    file.WriteString(fmt.Sprintf("Last_section_number:%d\n", pat.Last_section_number))
    for i, pmt := range pat.Pmts {
        file.WriteString(fmt.Sprintf("----pmt %d\n", i))
        file.WriteString(fmt.Sprintf("    program_number:%d\n", pmt.Program_number))
        if pmt.Program_number == 0x0000 {
            file.WriteString(fmt.Sprintf("    network_PID:%d\n", pmt.PID))
        } else {
            file.WriteString(fmt.Sprintf("    program_map_PID:%d\n", pmt.PID))
        }
    }
}

func (pat *Pat) Encode(bsw *codec.BitStreamWriter) {
    bsw.PutUint8(0x00, 8)
    loc := bsw.ByteOffset()
    bsw.PutUint8(pat.Section_syntax_indicator, 1)
    bsw.PutUint8(0x00, 1)
    bsw.PutUint8(0x03, 2)
    bsw.PutUint16(0, 12)
    bsw.Markdot()
    bsw.PutUint16(pat.Transport_stream_id, 16)
    bsw.PutUint8(0x03, 2)
    bsw.PutUint8(pat.Version_number, 5)
    bsw.PutUint8(pat.Current_next_indicator, 1)
    bsw.PutUint8(pat.Section_number, 8)
    bsw.PutUint8(pat.Last_section_number, 8)
    for _, pms := range pat.Pmts {
        bsw.PutUint16(pms.Program_number, 16)
        bsw.PutUint8(0x07, 3)
        bsw.PutUint16(pms.PID, 13)
    }
    length := bsw.DistanceFromMarkDot()
    //|Section_syntax_indicator|'0'|reserved|Section_length|
    pat.Section_length = uint16(length)/8 + 4
    bsw.SetUint16(pat.Section_length&0x0FFF|(uint16(pat.Section_syntax_indicator)<<15)|0x3000, loc)
    crc := codec.CalcCrc32(0xffffffff, bsw.Bits()[bsw.ByteOffset()-int(pat.Section_length-4)-3:bsw.ByteOffset()])
    tmpcrc := make([]byte, 4)
    binary.LittleEndian.PutUint32(tmpcrc, crc)
    bsw.PutBytes(tmpcrc)
}

func (pat *Pat) Decode(bs *codec.BitStream) error {
    pat.Table_id = bs.Uint8(8)

    if pat.Table_id != uint8(TS_TID_PAS) {
        return errors.New("table id is Not TS_TID_PAS")
    }
    pat.Section_syntax_indicator = bs.Uint8(1)
    bs.SkipBits(3)
    pat.Section_length = bs.Uint16(12)
    pat.Transport_stream_id = bs.Uint16(16)
    bs.SkipBits(2)
    pat.Version_number = bs.Uint8(5)
    pat.Current_next_indicator = bs.Uint8(1)
    pat.Section_number = bs.Uint8(8)
    pat.Last_section_number = bs.Uint8(8)
    for i := 0; i+4 <= int(pat.Section_length)-5-4; i = i + 4 {
        tmp := PmtPair{
            Program_number: 0,
            PID:            0,
        }
        tmp.Program_number = bs.Uint16(16)
        bs.SkipBits(3)
        tmp.PID = bs.Uint16(13)
        pat.Pmts = append(pat.Pmts, tmp)
    }
    return nil
}

type StreamPair struct {
    StreamType     uint8  //8 uimsbf
    Elementary_PID uint16 //13 uimsbf
    ES_Info_Length uint16 //12 uimsbf
}

type Pmt struct {
    Table_id                 uint8  //8  uimsbf
    Section_syntax_indicator uint8  //1  bslbf
    Section_length           uint16 //12 uimsbf
    Program_number           uint16 //16 uimsbf
    Version_number           uint8  //5  uimsbf
    Current_next_indicator   uint8  //1  bslbf
    Section_number           uint8  //8  uimsbf
    Last_section_number      uint8  //8  uimsbf
    PCR_PID                  uint16 //13 uimsbf
    Program_info_length      uint16 //12 uimsbf
    Streams                  []StreamPair
}

func NewPmt() *Pmt {
    return &Pmt{
        Table_id: uint8(TS_TID_PMS),
        Streams:  make([]StreamPair, 0, 8),
    }
}

func (pmt *Pmt) PrettyPrint(file *os.File) {
    file.WriteString(fmt.Sprintf("Table id:%d\n", pmt.Table_id))
    file.WriteString(fmt.Sprintf("Section_syntax_indicator:%d\n", pmt.Section_syntax_indicator))
    file.WriteString(fmt.Sprintf("Section_length:%d\n", pmt.Section_length))
    file.WriteString(fmt.Sprintf("Program_number:%d\n", pmt.Program_number))
    file.WriteString(fmt.Sprintf("Version_number:%d\n", pmt.Version_number))
    file.WriteString(fmt.Sprintf("Current_next_indicator:%d\n", pmt.Current_next_indicator))
    file.WriteString(fmt.Sprintf("Section_number:%d\n", pmt.Section_number))
    file.WriteString(fmt.Sprintf("Last_section_number:%d\n", pmt.Last_section_number))
    file.WriteString(fmt.Sprintf("PCR_PID:%d\n", pmt.PCR_PID))
    file.WriteString(fmt.Sprintf("program_info_length:%d\n", pmt.Program_info_length))
    for i, stream := range pmt.Streams {
        file.WriteString(fmt.Sprintf("----stream %d\n", i))
        if stream.StreamType == uint8(TS_STREAM_AAC) {
            file.WriteString("    stream_type:AAC\n")
        } else if stream.StreamType == uint8(TS_STREAM_H264) {
            file.WriteString("    stream_type:H264\n")
        } else if stream.StreamType == uint8(TS_STREAM_H265) {
            file.WriteString("    stream_type:H265\n")
        }
        file.WriteString(fmt.Sprintf("    elementary_PID:%d\n", stream.Elementary_PID))
        file.WriteString(fmt.Sprintf("    ES_info_length:%d\n", stream.ES_Info_Length))
    }
}

func (pmt *Pmt) Encode(bsw *codec.BitStreamWriter) {
    bsw.PutUint8(pmt.Table_id, 8)
    loc := bsw.ByteOffset()
    bsw.PutUint8(pmt.Section_syntax_indicator, 1)
    bsw.PutUint8(0x00, 1)
    bsw.PutUint8(0x03, 2)
    bsw.PutUint16(pmt.Section_length, 12)
    bsw.Markdot()
    bsw.PutUint16(pmt.Program_number, 16)
    bsw.PutUint8(0x03, 2)
    bsw.PutUint8(pmt.Version_number, 5)
    bsw.PutUint8(pmt.Current_next_indicator, 1)
    bsw.PutUint8(pmt.Section_number, 8)
    bsw.PutUint8(pmt.Last_section_number, 8)
    bsw.PutUint8(0x07, 3)
    bsw.PutUint16(pmt.PCR_PID, 13)
    bsw.PutUint8(0x0f, 4)
    //TODO Program info length
    bsw.PutUint16(0x0000 /*pmt.Program_info_length*/, 12)
    for _, stream := range pmt.Streams {
        bsw.PutUint8(stream.StreamType, 8)
        bsw.PutUint8(0x00, 3)
        bsw.PutUint16(stream.Elementary_PID, 13)
        bsw.PutUint8(0x00, 4)
        //TODO ES_info
        bsw.PutUint8(0 /*ES_info_length*/, 12)
    }
    length := bsw.DistanceFromMarkDot()
    pmt.Section_length = uint16(length)/8 + 4
    bsw.SetUint16(pmt.Section_length&0x0FFF|(uint16(pmt.Section_syntax_indicator)<<15)|0x3000, loc)
    crc := codec.CalcCrc32(0xffffffff, bsw.Bits()[bsw.ByteOffset()-int(pmt.Section_length-4)-3:bsw.ByteOffset()])
    tmpcrc := make([]byte, 4)
    binary.LittleEndian.PutUint32(tmpcrc, crc)
    bsw.PutBytes(tmpcrc)
}

func (pmt *Pmt) Decode(bs *codec.BitStream) error {
    pmt.Table_id = bs.Uint8(8)
    if pmt.Table_id != uint8(TS_TID_PMS) {
        return errors.New("table id is Not TS_TID_PAS")
    }
    pmt.Section_syntax_indicator = bs.Uint8(1)
    bs.SkipBits(3)
    pmt.Section_length = bs.Uint16(12)
    pmt.Program_number = bs.Uint16(16)
    bs.SkipBits(2)
    pmt.Version_number = bs.Uint8(5)
    pmt.Current_next_indicator = bs.Uint8(1)
    pmt.Section_number = bs.Uint8(8)
    pmt.Last_section_number = bs.Uint8(8)
    bs.SkipBits(3)
    pmt.PCR_PID = bs.Uint16(13)
    bs.SkipBits(4)
    pmt.Program_info_length = bs.Uint16(12)
    //TODO N loop descriptors
    bs.SkipBits(int(pmt.Program_info_length) * 8)
    //fmt.Printf("section length %d pmt.Pogram_info_length=%d\n", pmt.Section_length, pmt.Pogram_info_length)
    for i := 0; i < int(pmt.Section_length)-9-int(pmt.Program_info_length)-4; {
        tmp := StreamPair{
            StreamType:     0,
            Elementary_PID: 0,
            ES_Info_Length: 0,
        }
        tmp.StreamType = bs.Uint8(8)
        bs.SkipBits(3)
        tmp.Elementary_PID = bs.Uint16(13)
        bs.SkipBits(4)
        tmp.ES_Info_Length = bs.Uint16(12)
        //TODO N loop descriptors
        bs.SkipBits(int(tmp.ES_Info_Length) * 8)
        pmt.Streams = append(pmt.Streams, tmp)
        i += 5 + int(tmp.ES_Info_Length)
    }
    return nil
}