Method EncodePES

src/brpc/ts.cpp:1404–1475

}

butil::Status TsWriter::EncodePES(TsMessage* msg, TsStream sid, TsPid pid,
                                 bool pure_audio) {
    if (msg->payload.empty()) {
        return butil::Status::OK();
    }
    if (sid != TS_STREAM_VIDEO_H264 &&
        sid != TS_STREAM_AUDIO_MP3 &&
        sid != TS_STREAM_AUDIO_AAC) {
        LOG(WARNING) << "Ignore unknown stream_id=" << sid;
        return butil::Status::OK();
    }

    TsChannel* channel = _tschan_group.get(pid);
    if (channel == NULL) {
        return butil::Status(EINVAL, "Fail to get channel on pid=%d", (int)pid);
    }

    bool first_msg = true;
    while (!msg->payload.empty()) {
        TsPacket pkt(&_tschan_group);
        if (first_msg) {
            first_msg = false;
            bool write_pcr = msg->write_pcr;
            // for pure audio, always write pcr.
            // TODO: maybe only need to write at begin and end of ts.
            if (pure_audio && is_audio(msg->sid)) {
                write_pcr = true;
            }

            // it's ok to set pcr equals to dts,
            int64_t pcr = write_pcr ? msg->dts : -1;
            
            // TODO: FIXME: figure out why use discontinuity of msg
            pkt.CreateAsPESFirst(pid, msg->sid, channel->continuity_counter++,
                               msg->is_discontinuity, pcr, msg->dts,
                               msg->pts, msg->payload.size());
        } else {
            pkt.CreateAsPESContinue(pid, channel->continuity_counter++);
        }

        char buf[TS_PACKET_SIZE];

        // set the left bytes with 0xFF.
        size_t pkt_size = pkt.ByteSize();
        CHECK_LT(pkt_size, TS_PACKET_SIZE);

        size_t left = std::min(msg->payload.size(), TS_PACKET_SIZE - pkt_size);
        const size_t nb_stuffings = TS_PACKET_SIZE - pkt_size - left;
        if (nb_stuffings > 0) {
            // set all bytes to stuffings.
            memset(buf, 0xFF, TS_PACKET_SIZE);

            pkt.AddPadding(nb_stuffings);

            pkt_size = pkt.ByteSize();   // size changed, recalculate.
            CHECK_LT(pkt_size, TS_PACKET_SIZE);

            left = std::min(msg->payload.size(), TS_PACKET_SIZE - pkt_size);