live555开发接收RTP PS流，转发rtsp裸流，支持H264，H265

Love The Way You Lie 2024-03-01 08:26 57阅读 0赞

1.首先需要扩展FramedFilter类专门用来解封装PS流，即输入一帧PS rtp数据，输出一帧裸流数据，h264或者h265

class MP2PVideoToRawLiveSource: public  FramedFilter{
    
    public:
      static MP2PVideoToRawLiveSource* createNew(UsageEnvironment& env, FramedSource* inputSource);
      //static MP2PVideoToRawLiveSource* createNew(UsageEnvironment& env, FramedSource* inputSource, MP2PAudioToRawLiveSource *audioSource);
      FramedSource *getInputSource(){return fInputSource;}
    protected:
      virtual ~MP2PVideoToRawLiveSource();
    
    public:
      MP2PVideoToRawLiveSource(UsageEnvironment& env, FramedSource* inputSource);
      //MP2PVideoToRawLiveSource(UsageEnvironment& env, FramedSource* inputSource, MP2PAudioToRawLiveSource *audioSource);
      bool isH264(){
            if(fVideoCodec == H264_CODEC){
                return true;
            }
            else{
                return false;
            }
      }
      bool isH265(){
            if(fVideoCodec == H265_CODEC){
                return true;
            }
            else{
                return false;
            }
    
      }
    
    
      
    public:
        bool fRtp_receiving;
        bool fVideoCodecChange;
    
    protected:
      // redefined virtual functions:
    virtual void doGetNextFrame();
    
      static void afterGettingFrame(void* clientData, unsigned frameSize,
                                    unsigned numTruncatedBytes,
                                    struct timeval presentationTime,
                                    unsigned durationInMicroseconds);
      void afterGettingFrame1(unsigned frameSize,
    					  	unsigned numTruncatedBytes,
    						struct timeval presentationTime,
    						unsigned durationInMicroseconds);
    protected:
      VIDEO_CODEC fVideoCodec;
      
    private:
      //FramedSource* fInputSource;
      unsigned int fIframegop;
      unsigned char *fMP2P_frame_data;
      unsigned int fMP2P_frame_data_size;
      unsigned char *fMp2p_next_start_slice;
      unsigned int fMp2p_next_start_size;
      
      unsigned fPacketSize;
      unsigned fNumBitsSeenSoFar; // used by the getNextFrameBit*() routines
      unsigned char* fRaw_buf;
      RawFrameCache  fRawFrameCache[RAW_CACHE_NUM];
      int fRawFrameCount;
      int64_t fLastPesTime;
      unsigned int fTimestamp;
      struct timeval fMP2PPreTime;
      struct timeval fMP2PPreVideoTime;
      
    
    private:
      void pushRawCache(unsigned char *data, unsigned int size, unsigned int numTruncatedBytes, struct timeval presentationTime,
      unsigned int durationInMicroseconds);
    
      void createRawCache();
      RawFrameCache * popRawCache();
      void destroyRawCache();
    };

这个类可以看成一个管道，进去一个source出去一个source， 其中doGetNextFrame是继承来的虚函数，live555框架会去调用这个接口，并且把afterGettingFrame函数注册进去。

void MP2PVideoToRawLiveSource::doGetNextFrame() {
    
    if(fInputSource != NULL) {
    
     RawFrameCache* frame_cache = popRawCache();
     if(frame_cache){
        memcpy(fTo, frame_cache->frame_data, frame_cache->frame_size);
        delete[] frame_cache->frame_data;
        frame_cache->frame_data = NULL;
        fFrameSize = frame_cache->frame_size;
        fNumTruncatedBytes = frame_cache->numTruncatedBytes;
        fPresentationTime = frame_cache->presentationTime;
        fDurationInMicroseconds = frame_cache->durationInMicroseconds;  
        fMP2PPreVideoTime = fPresentationTime;
        //printf("######### video time %u\n", fPresentationTime.tv_sec);
        afterGetting(this);
        return;
        
     }
    
      fInputSource->getNextFrame(fTo, fMaxSize,
                                 MP2PVideoToRawLiveSource::afterGettingFrame, this,
                                 FramedSource::handleClosure, this);
    }else{
      nextTask() = envir().taskScheduler().scheduleDelayedTask(0,
                                     (TaskFunc*)FramedSource::handleClosure, this);    
        }
    }

等到下一次有帧数据的时候会调用afterGettingFrame函数，然后会调用afterGettingFrame1函数，在这里MP2PVideoToRawLiveSource::afterGettingFrame1就是解PS流封装的核心函数。

void MP2PVideoToRawLiveSource
     ::afterGettingFrame1(unsigned frameSize, unsigned numTruncatedBytes,
                          struct timeval presentationTime,
                          unsigned durationInMicroseconds) {
    
       //printf("########## fTo 4byte   %x  %x   %x  %x, frameSize %d, fMaxSize %u\n ", fTo[0], fTo[1], fTo[2], fTo[3], frameSize, fMaxSize);
         
     // 00 00 01 e0  + byte1 + byte2 + byte3 + byte4 + byte5(pes头后剩下的长度 len)  + len  + raw
         if(frameSize > 4){
            fRtp_receiving = true;
         }
         else{
            fFrameSize = 0;
            afterGetting(this);
            return;
        }
    
    
         
         int fpos = 0;
         int first_pes_find = 0;
         int new_ps_find = 0;
         int raw_pos = 0;
         int raw_buf_pos = 0;
     
     
         fFrameSize = frameSize;
         fNumTruncatedBytes = numTruncatedBytes;
         fPresentationTime = presentationTime;
         fDurationInMicroseconds = durationInMicroseconds;    
    
         fRawFrameCount = 0;
    
    
         
    #if 0
          //test write file 
          static FILE *mpg_fp = NULL;
          if(mpg_fp == NULL){
              mpg_fp = fopen("test_108_hevc.mpg","w+");
          }
      
          if(mpg_fp != NULL){
             
              //printf("######### frameSize %d\n",frameSize);
              fwrite(fTo, frameSize, 1, mpg_fp);
          }
    #endif  
    
        if(fMP2P_frame_data_size > 0 && fTo[0] == 0x00 && fTo[1] == 0x00 && fTo[2] == 0x01 && (fTo[3] == 0xba || fTo[3] == 0xc0)){
    
    
            memcpy(fMp2p_next_start_slice, fTo, frameSize);
            fMp2p_next_start_size = frameSize;
    
            memcpy(fTo, fMP2P_frame_data, fMP2P_frame_data_size);
            frameSize = fMP2P_frame_data_size;
            fFrameSize = frameSize;
            presentationTime = fMP2PPreTime;
            
                //fMP2PPreTime = fPresentationTime;
            if(fTo[3] == 0xc0){
                fMP2PPreTime = fPresentationTime;
            }
                
    
            memcpy(fMP2P_frame_data, fMp2p_next_start_slice, fMp2p_next_start_size);
            fMP2P_frame_data_size = fMp2p_next_start_size;
            
            
        }
        else{
            
            memcpy(fMP2P_frame_data + fMP2P_frame_data_size, fTo, frameSize);
            fMP2P_frame_data_size += frameSize;
            fFrameSize = 0;
            fMP2PPreTime = presentationTime;
            afterGetting(this);
            return;
        }
        
        
         if(frameSize < 4  || !(fTo[fpos] == 0x00 && fTo[fpos + 1] == 0x00 &&  fTo[fpos + 2] == 0x01)){
    
                 printf("##########  invaild  data  fTo 4byte   %x  %x   %x  %x, frameSize %d, fMaxSize %u\n ", fTo[0], fTo[1], fTo[2], fTo[3], frameSize, fMaxSize); 
             
                 fFrameSize = 0;
                 afterGetting(this);
                 return;
         }
    
    
         unsigned char *fRaw_buf = new unsigned char[frameSize];
         memset(fRaw_buf, 0, frameSize);
    
    
    
        #if 0
        fTimestamp  += 3600;
        unsigned int tv_sec = fTimestamp/(double)90000;
        //unsigned int tv_usec = tv_sec*1000000; 
        fMP2PPreTime.tv_sec = tv_sec;
        fMP2PPreTime.tv_usec = (unsigned)((fTimestamp/(double)90000 - tv_sec)*1000000);
        
        presentationTime = fMP2PPreTime;
        //printf("######### presentationTime time %u\n", presentationTime.tv_sec);
        #endif   
    
    
         
         
         //去掉PS，PES头信息，fRaw_buf含有起始码00 00 00 01的裸流
         unsigned char *pes_header = NULL;
         unsigned char *pts_pos = NULL;
         int64_t pts = 0;
         unsigned char PTS_DTS_flags;
         unsigned int private_data_size = 0;
         while(fpos  < frameSize){
    
                #if 0  //parse  pes  pts and dts
                if(fTo[fpos] == 0x00 && fTo[fpos + 1] == 0x00 &&  fTo[fpos + 2] == 0x01){
                        if(fTo[fpos + 3] == 0xe0 || fTo[fpos + 3] == 0xc0){                    
                         pes_header = fTo + fpos + 3;
                         //PTS_DTS_flags 
                         PTS_DTS_flags = pes_header[4]>>6;
                         //pes头部有PTS
                         if(PTS_DTS_flags == 0x2 || PTS_DTS_flags == 0x3){
                            
                        //PTS占用5个字节， 在这5个字节中取33位
                        /*
                            5             4               3               2               1 
                            7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 7 6 5 4 3 2 1 0 
                           |0 0 1 1|PTS1 |1|       PTS2                  |1|       PTS3                   |
                                   |32-30| |       29-15                 | |       14-0                   |
                           PTS[32…30]：占位3bit；  PTS[29…15]：占位15bit； PTS[14…0]：占位15bit；
                           PTS = （PTS1 & 0x0e) << 29 + (PTS2 & 0xfffe) << 14 + (PTS3 & 0xfffe ) >> 1;
                        */
                           pts_pos = pes_header + 6;
                           pts = (int64_t)(*pts_pos & 0x0e) << 29 | ((*(unsigned short*)(pts_pos + 1) >> 1) << 15) |
                           (*(unsigned short*)(pts_pos + 3) >> 1);
    
                           if(fTo[fpos + 3] == 0xe0){
                                unsigned int tv_sec = pts/(double)90000;
                                unsigned int tv_usec = tv_sec*1000000; 
                                presentationTime.tv_sec += tv_sec;
                                presentationTime.tv_usec += (unsigned)((pts/(double)90000 - tv_sec)*1000000);
                                fMP2PPreTime = presentationTime;
                                printf("########## PTS exit in PES heade  pts  %u, sec pts %f\n",pts, pts/(double)90000);
                           }
                           else{
                                presentationTime = fMP2PPreTime;
                           }
                            //printf("########## PTS exit in PES heade  pts  %u, sec pts %f\n",pts, pts/(double)90000);
                                
                         }
                         else
                            printf("#### no PTS PTS_DTS_flags %u\n", PTS_DTS_flags);
                           
                        }
               }
                #endif
         
                 //视频
                 if(fTo[fpos] == 0x00 && fTo[fpos + 1] == 0x00 &&  fTo[fpos + 2] == 0x01 &&  fTo[fpos + 3] == 0xe0){
                     if(fpos + 3 + 5 < frameSize){
                         if(raw_pos > 0){
                             memcpy(fRaw_buf + raw_buf_pos, fTo + raw_pos, fpos - raw_pos);                         
                             raw_buf_pos  = raw_buf_pos + fpos - raw_pos;
                         }
                        
                         
                         //拿到ES流裸流的偏移
                         raw_pos = fpos + 3 + 5 + 1 + (int)fTo[fpos + 3 + 5];
                         fpos = raw_pos;
                     }
                     else{
                         break;
                     }
                 }
                 //音频
                 else if(fTo[fpos] == 0x00 && fTo[fpos + 1] == 0x00 &&  fTo[fpos + 2] == 0x01 &&  fTo[fpos + 3] == 0xc0){
                    //放入音频缓冲
                    //printf("########### find audio data\n");
                     int audio_buf_pos = fpos + 3 + 5 + 1 + (int)fTo[fpos + 3 + 5];
                     int audio_buf_size = frameSize - audio_buf_pos;
                     //presentationTime = fMP2PPreVideoTime;
                     presentationTime = fMP2PPreTime;
                     //printf("######### audio time %u\n", presentationTime.tv_sec);
                     audioFrameAfterGetting(fTo + audio_buf_pos, audio_buf_size, numTruncatedBytes, presentationTime, durationInMicroseconds);
                     fFrameSize = 0;
                     afterGetting(this);
                     delete fRaw_buf;
                     return;
                 }
    
                 //海康PS流私有数据
                 else if(fTo[fpos] == 0x00 && fTo[fpos + 1] == 0x00 &&  fTo[fpos + 2] == 0x01 &&  fTo[fpos + 3] == 0xbd){
                    //printf("############## PS stream  private data will lost it\n");
                    private_data_size = frameSize - fpos;
                    break;
                 }
                 else{
                     fpos++;
                 }
             }
     
         
    
         
         memcpy(fRaw_buf + raw_buf_pos, fTo + raw_pos, frameSize - raw_pos - private_data_size);
         raw_buf_pos = raw_buf_pos + frameSize - raw_pos;
     
         int raw_buf_size = raw_buf_pos; 
    
    
         
         //去掉裸流起始码 00 00 00 01 sps pps vps 分包发送
         int start_nalu_pos = 0;
         int no_start_raw_buf_pos = 0;
         int copy_size = 0;
         int no_start_raw_len = 0;
         for(int i = 0; i + 4 < raw_buf_size;){
             if(fRaw_buf[i] == 0x00 && fRaw_buf[i+1] == 0x00 && fRaw_buf[i+2] == 0x00 && fRaw_buf[i+3] == 0x01){
                
                 if(fRaw_buf[i + 4] == 0x67 || fRaw_buf[i + 4] == 0x68 || fRaw_buf[i + 4] == 0x06 || fRaw_buf[i + 4] == 0x65 ){
                     if(fVideoCodec != NONE_CODEC && fVideoCodec != H264_CODEC){
                        printf("######## VideoCodec change  to H264\n");
                            fVideoCodecChange = true;
                            fFrameSize = 0;
                            doStopGettingFrames();
                            return;
                     }
                     if(fVideoCodec == NONE_CODEC)
                        fVideoCodec = H264_CODEC;
                     
                 }
    
                 else if(fRaw_buf[i + 4] == 0x40 || fRaw_buf[i + 4] == 0x26 ||fRaw_buf[i + 4] == 0x42 || fRaw_buf[i + 4] == 0x44 || fRaw_buf[i + 4] == 0x4e){
                    if(fVideoCodec != NONE_CODEC && fVideoCodec != H265_CODEC){
                            printf("######## VideoCodec change  to H265\n");
                            fVideoCodecChange = true;
                            fFrameSize = 0;
                            doStopGettingFrames();
                            return;
                    }
                    
                    if(fVideoCodec == NONE_CODEC){
                        fVideoCodec = H265_CODEC;
                    }
                 }
                 
                 if(start_nalu_pos > 0){
                    copy_size = i - start_nalu_pos;
                    
                    pushRawCache(fRaw_buf + start_nalu_pos, copy_size, numTruncatedBytes,  presentationTime,durationInMicroseconds);
                    fFrameSize = (unsigned int)copy_size; 
                    no_start_raw_buf_pos += copy_size;
                 }
                 start_nalu_pos = i + 4;
                 i += 4;
             }
             else
                i++;
             
         }
    
         copy_size = raw_buf_size - start_nalu_pos;
         if(copy_size > 0){         
             pushRawCache(fRaw_buf + start_nalu_pos, copy_size, numTruncatedBytes,  presentationTime,durationInMicroseconds);
         }
         
         fFrameSize = 0;
         RawFrameCache* frame_cache = popRawCache();
         if(frame_cache){
            memcpy(fTo, frame_cache->frame_data, frame_cache->frame_size);
            delete[] frame_cache->frame_data;
            frame_cache->frame_data = NULL;
            fFrameSize = frame_cache->frame_size;
            fNumTruncatedBytes = frame_cache->numTruncatedBytes;
            fPresentationTime = frame_cache->presentationTime;
            fDurationInMicroseconds = frame_cache->durationInMicroseconds;
            //printf("######### video time %u\n", fPresentationTime.tv_sec);
            fMP2PPreVideoTime = fPresentationTime;
         }
    
        delete fRaw_buf;
        afterGetting(this);
     }

首先需要说明下，live555在正常收rtp流的时候，当调用这个接口的时候fTo里面放的是一帧数据，但是对于接收rtp PS流，这里每次回调只有一个rtp包数据。我们也可以通过修改参数，让fTo每次回调有一帧数据，但是当数据源的rtp包没有mark标志的时候这里将一直无法被调用，因为live底层认为只有遇到mark标志才是新的一帧的开始。所以这里还是得一个个rtp包处理，开发时我遇到过有些摄像机得出PS流就没有mark标志。所以在这里说明下这个接口主要工作：  
1.将收到的rtp数据保存在缓冲中，暂时不传递给下一个souce，等到发现有PS头的时候再将完整一帧的数据回调给下一个source或sink。  
2.去掉PS头，PES头，解析PES包里面的PTS，在这里我用的是rtp包的时间戳，PES包的时间戳转发出去的流感觉不是很流畅。  
3.将流数据的nalu起始码去掉，将完整的裸流数据回调给H264VideoStreamDiscreteFramer处理即可

还有一个地方也需要注意，对于裸流的sps,pps,vps等视频参数信息，有时候是放到一个PS包里面的，但是这个接口每次又只能回调一帧数据，也就是说对于sps,pps每次只能回调一个。所以这里我实现了一个数组这些数据，等到下一次回调的时候，再把缓冲的sps,pps数据传给后面的source。上面的doGetNextFrame函数很好说明了这个机制，每次判断缓冲是否有数据，如果有则将缓冲数据回调下去。