优化frame性能及整理代码

src/Extension/H264.cpp

@@ -96,6 +96,174 @@ size_t prefixSize(const char *ptr, size_t len){
     return 0;
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+H264Track::H264Track(const string &sps,const string &pps,int sps_prefix_len,int pps_prefix_len){
+    _sps = sps.substr(sps_prefix_len);
+    _pps = pps.substr(pps_prefix_len);
+    onReady();
+}
+
+H264Track::H264Track(const Frame::Ptr &sps,const Frame::Ptr &pps){
+    if(sps->getCodecId() != CodecH264 || pps->getCodecId() != CodecH264 ){
+        throw std::invalid_argument("必须输入H264类型的帧");
+    }
+    _sps = string(sps->data() + sps->prefixSize(),sps->size() - sps->prefixSize());
+    _pps = string(pps->data() + pps->prefixSize(),pps->size() - pps->prefixSize());
+    onReady();
+}
+
+const string &H264Track::getSps() const{
+    return _sps;
+}
+
+const string &H264Track::getPps() const{
+    return _pps;
+}
+
+CodecId H264Track::getCodecId() const {
+    return CodecH264;
+}
+
+int H264Track::getVideoHeight() const {
+    return _height;
+}
+
+int H264Track::getVideoWidth() const {
+    return _width;
+}
+
+float H264Track::getVideoFps() const {
+    return _fps;
+}
+
+bool H264Track::ready() {
+    return !_sps.empty() && !_pps.empty();
+}
+
+void H264Track::inputFrame(const Frame::Ptr &frame) {
+    using H264FrameInternal = FrameInternal<H264FrameNoCacheAble>;
+
+    int type = H264_TYPE(*((uint8_t *) frame->data() + frame->prefixSize()));
+    if (type != H264Frame::NAL_B_P && type != H264Frame::NAL_IDR) {
+        //非I/B/P帧情况下，split一下，防止多个帧粘合在一起
+        splitH264(frame->data(), frame->size(), frame->prefixSize(), [&](const char *ptr, size_t len, size_t prefix) {
+            H264FrameInternal::Ptr sub_frame = std::make_shared<H264FrameInternal>(frame, (char *) ptr, len, prefix);
+            inputFrame_l(sub_frame);
+        });
+    } else {
+        inputFrame_l(frame);
+    }
+}
+
+void H264Track::onReady(){
+    getAVCInfo(_sps,_width,_height,_fps);
+}
+
+Track::Ptr H264Track::clone() {
+    return std::make_shared<std::remove_reference<decltype(*this)>::type >(*this);
+}
+
+void H264Track::inputFrame_l(const Frame::Ptr &frame){
+    int type = H264_TYPE(*((uint8_t *) frame->data() + frame->prefixSize()));
+    switch (type) {
+        case H264Frame::NAL_SPS: {
+            _sps = string(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize());
+            break;
+        }
+        case H264Frame::NAL_PPS: {
+            _pps = string(frame->data() + frame->prefixSize(), frame->size() - frame->prefixSize());
+            break;
+        }
+        case H264Frame::NAL_IDR: {
+            insertConfigFrame(frame);
+            VideoTrack::inputFrame(frame);
+            break;
+        }
+        case H264Frame::NAL_AUD: {
+            //忽略AUD帧;
+            break;
+        }
+
+        default:
+            VideoTrack::inputFrame(frame);
+            break;
+    }
+
+    _is_idr = type == H264Frame::NAL_IDR;
+    if (_width == 0 && ready()) {
+        onReady();
+    }
+}
+
+void H264Track::insertConfigFrame(const Frame::Ptr &frame){
+    if(_is_idr){
+        return;
+    }
+
+    if(!_sps.empty()){
+        auto spsFrame = FrameImp::create<H264Frame>();
+        spsFrame->_prefix_size = 4;
+        spsFrame->_buffer.assign("\x00\x00\x00\x01",4);
+        spsFrame->_buffer.append(_sps);
+        spsFrame->_dts = frame->dts();
+        VideoTrack::inputFrame(spsFrame);
+    }
+
+    if(!_pps.empty()){
+        auto ppsFrame = FrameImp::create<H264Frame>();
+        ppsFrame->_prefix_size = 4;
+        ppsFrame->_buffer.assign("\x00\x00\x00\x01",4);
+        ppsFrame->_buffer.append(_pps);
+        ppsFrame->_dts = frame->dts();
+        VideoTrack::inputFrame(ppsFrame);
+    }
+}
+
+class H264Sdp : public Sdp {
+public:
+    H264Sdp(const string &strSPS, const string &strPPS, int bitrate, int payload_type = 96)
+        : Sdp(90000, payload_type) {
+        //视频通道
+        _printer << "m=video 0 RTP/AVP " << payload_type << "\r\n";
+        if (bitrate) {
+            _printer << "b=AS:" << bitrate << "\r\n";
+        }
+        _printer << "a=rtpmap:" << payload_type << " H264/" << 90000 << "\r\n";
+        _printer << "a=fmtp:" << payload_type << " packetization-mode=1; profile-level-id=";
+
+        char strTemp[100];
+        uint32_t profile_level_id = 0;
+        if (strSPS.length() >= 4) { // sanity check
+            profile_level_id = (uint8_t(strSPS[1]) << 16) |
+                               (uint8_t(strSPS[2]) << 8) |
+                               (uint8_t(strSPS[3])); // profile_idc|constraint_setN_flag|level_idc
+        }
+        memset(strTemp, 0, 100);
+        snprintf(strTemp, sizeof(strTemp), "%06X", profile_level_id);
+        _printer << strTemp;
+        _printer << "; sprop-parameter-sets=";
+        memset(strTemp, 0, 100);
+        av_base64_encode(strTemp, 100, (uint8_t *) strSPS.data(), (int) strSPS.size());
+        _printer << strTemp << ",";
+        memset(strTemp, 0, 100);
+        av_base64_encode(strTemp, 100, (uint8_t *) strPPS.data(), (int) strPPS.size());
+        _printer << strTemp << "\r\n";
+        _printer << "a=control:trackID=" << (int) TrackVideo << "\r\n";
+    }
+
+    string getSdp() const {
+        return _printer;
+    }
+
+    CodecId getCodecId() const {
+        return CodecH264;
+    }
+
+private:
+    _StrPrinter _printer;
+};
+
 Sdp::Ptr H264Track::getSdp() {
     if(!ready()){
         WarnL << getCodecName() << " Track未准备好";
@@ -103,6 +271,48 @@ Sdp::Ptr H264Track::getSdp() {
     }
     return std::make_shared<H264Sdp>(getSps(), getPps(), getBitRate() / 1024);
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+bool H264Frame::keyFrame() const {
+    return H264_TYPE(_buffer[_prefix_size]) == H264Frame::NAL_IDR;
+}
+
+bool H264Frame::configFrame() const {
+    switch (H264_TYPE(_buffer[_prefix_size])) {
+        case H264Frame::NAL_SPS:
+        case H264Frame::NAL_PPS: return true;
+        default: return false;
+    }
+}
+
+H264Frame::H264Frame() {
+    _codec_id = CodecH264;
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+H264FrameNoCacheAble::H264FrameNoCacheAble(char *ptr,size_t size,uint32_t dts , uint32_t pts ,size_t prefix_size){
+    _ptr = ptr;
+    _size = size;
+    _dts = dts;
+    _pts = pts;
+    _prefix_size = prefix_size;
+    _codec_id = CodecH264;
+}
+
+bool H264FrameNoCacheAble::keyFrame() const {
+    return H264_TYPE(_ptr[_prefix_size]) == H264Frame::NAL_IDR;
+}
+
+bool H264FrameNoCacheAble::configFrame() const {
+    switch (H264_TYPE(_ptr[_prefix_size])) {
+        case H264Frame::NAL_SPS:
+        case H264Frame::NAL_PPS: return true;
+        default: return false;
+    }
+}
+
 }//namespace mediakit