rtp_bytestream.cpp

完整的RTP RTSP代码库

		m_name, rtp_ts, m_first_pak_rtp_ts, m_first_pak_ts, 
		timetick, adder, ts_adder);
#endif
  }
#ifdef DEBUG_RTP_TS
  rtp_message(LOG_DEBUG,"%s time "U64" %u", m_name, timetick, rtp_ts);
#endif
  // record time
  m_last_rtp_ts = rtp_ts;
  m_last_realtime = timetick;
  return (timetick);
}

bool CRtpByteStreamBase::find_mbit (void)
{
  rtp_packet *temp, *first;
  if (m_head == NULL) return false;
  SDL_LockMutex(m_rtp_packet_mutex);
  first = temp = m_head;
  do {
    if (temp->rtp_pak_m == 1) {
      SDL_UnlockMutex(m_rtp_packet_mutex);
      return true;
    }
    temp = temp->rtp_next;
  } while (temp != NULL && temp != first);
  SDL_UnlockMutex(m_rtp_packet_mutex);
  return false;
}
void CRtpByteStreamBase::display_status(void)
{
  SDL_LockMutex(m_rtp_packet_mutex);
  rtp_packet *pak;
  uint32_t count;
  int32_t diff;
  if (m_head == NULL) {
    rtp_message(LOG_DEBUG, "%s - no packets", m_name);
    rtp_message(LOG_DEBUG, "%s - last rtp %u last realtime "U64 " wrap "U64,
		m_name, m_last_rtp_ts, m_last_realtime, m_wrap_offset);
    SDL_UnlockMutex(m_rtp_packet_mutex);
    return;
  }
  pak = m_head;
  count = 1;
  for (pak = m_head; pak->rtp_next != m_head; pak = pak->rtp_next) count++;
  diff = m_tail->rtp_pak_ts - m_head->rtp_pak_ts;
  rtp_message(LOG_DEBUG, "%s - %u paks head seq %u ts %u tail seq %u ts %u "D64, 
	      m_name, count, m_head->rtp_pak_seq, m_head->rtp_pak_ts, 
	      m_tail->rtp_pak_seq, m_tail->rtp_pak_ts, diff * 1000 / m_timescale);
  rtp_message(LOG_DEBUG, "%s - last rtp %u last realtime "U64 " wrap "U64,
	      m_name, m_last_rtp_ts, m_last_realtime, m_wrap_offset);
  uint32_t last_rtp_ts = m_last_rtp_ts;
  uint64_t last_realtime = m_last_realtime;
  uint64_t wrap_offset = m_wrap_offset;
  uint64_t msec = rtp_ts_to_msec(m_head->rtp_pak_ts, 
				 m_head->pd.rtp_pd_timestamp,
				 wrap_offset);
  m_last_rtp_ts = last_rtp_ts;
  m_last_realtime = last_realtime;
  rtp_message(LOG_DEBUG, "head ts "U64, msec);
  
#if 0
  int64_t t1, t2;
  t1 = (int64_t)m_first_pak_rtp_ts;
  t2 = (int64_t)m_first_pak_ts;
  rtp_message(LOG_DEBUG, "%s - first %u "D64" real "U64" "D64, m_name,
	      m_first_pak_rtp_ts, t1, m_first_pak_ts, t2);
#endif
  SDL_UnlockMutex(m_rtp_packet_mutex);
}

CRtpByteStream::CRtpByteStream(const char *name,
			       format_list_t *fmt,
			       unsigned int rtp_pt,
			       int ondemand,
			       uint64_t tickpersec,
			       rtp_packet **head, 
			       rtp_packet **tail,
			       int rtp_seq_set,
			       uint16_t rtp_base_seq,
			       int rtp_ts_set,
			       uint32_t rtp_base_ts,
			       int rtcp_received,
			       uint32_t ntp_frac,
			       uint32_t ntp_sec,
			       uint32_t rtp_ts) :
  CRtpByteStreamBase(name, fmt, rtp_pt, ondemand, tickpersec, head, tail,
		     rtp_seq_set, rtp_base_seq, rtp_ts_set, rtp_base_ts, 
		     rtcp_received, ntp_frac, ntp_sec, rtp_ts)
{
  m_buffer = (uint8_t *)malloc(4096);
  m_buffer_len_max = 4096;
  m_bytes_used = m_buffer_len = 0;
}

CRtpByteStream::~CRtpByteStream (void)
{
  free(m_buffer);
  m_buffer = NULL;
}

void CRtpByteStream::reset (void)
{
  m_buffer_len = m_bytes_used = 0;
  CRtpByteStreamBase::reset();
}

bool CRtpByteStream::start_next_frame (uint8_t **buffer, 
				       uint32_t *buflen,
				       frame_timestamp_t *pts,
				       void **ud)
{
  uint16_t seq = 0;
  uint32_t rtp_ts = 0;
  uint64_t timetick;
  uint64_t ts = 0;
  int first = 0;
  int finished = 0;
  rtp_packet *rpak;
  int32_t diff;

  diff = m_buffer_len - m_bytes_used;

  if (diff >= 2) {
    // Still bytes in the buffer...
    *buffer = m_buffer + m_bytes_used;
    *buflen = diff;
#ifdef DEBUG_RTP_FRAMES
    rtp_message(LOG_DEBUG, "%s Still left - %d bytes", m_name, *buflen);
#endif
#if 0
    rtp_message(LOG_DEBUG, "%s start %02x %02x %02x %02x %02x", m_name,
		(*buffer)[0],
		(*buffer)[1],
		(*buffer)[2],
		(*buffer)[3],
		(*buffer)[4]);
#endif
    pts->msec_timestamp = m_last_realtime;
    pts->audio_freq_timestamp = m_last_rtp_ts;
    pts->audio_freq = m_timescale;
    pts->timestamp_is_pts = true;
    return true;
  } else {
    check_seq(m_head->rtp_pak_seq);

    m_buffer_len = 0;
    while (finished == 0) {
      rpak = m_head;
      if (rpak == NULL) { 
	// incomplete frame - bail on this
	player_error_message("%s - This should never happen - rtp bytestream"
			     "is incomplete and active", m_name);
	player_error_message("Please report to mpeg4ip");
	player_error_message("first %d seq %u ts %x blen %d",
			     first, seq, rtp_ts, m_buffer_len);
	m_buffer_len = 0;
	m_bytes_used = 0;
	return 0;
      }
	
      remove_packet_rtp_queue(rpak, 0);
      
      if (first == 0) {
	seq = rpak->rtp_pak_seq + 1;
	ts = rpak->pd.rtp_pd_timestamp;
	rtp_ts = rpak->rtp_pak_ts;
	first = 1;
      } else {
	if ((seq != rpak->rtp_pak_seq) ||
	    (rtp_ts != rpak->rtp_pak_ts)) {
	  if (seq != rpak->rtp_pak_seq) {
	    rtp_message(LOG_INFO, "%s missing rtp sequence - should be %u is %u", 
			m_name, seq, rpak->rtp_pak_seq);
	  } else {
	    rtp_message(LOG_INFO, "%s timestamp error - seq %u should be %x is %x", 
			m_name, seq, rtp_ts, rpak->rtp_pak_ts);
	  }
	  m_buffer_len = 0;
	  rtp_ts = rpak->rtp_pak_ts;
	}
	seq = rpak->rtp_pak_seq + 1;
      }
      uint8_t *from;
      uint32_t len;
      from = (uint8_t *)rpak->rtp_data + m_skip_on_advance_bytes;
      len = rpak->rtp_data_len - m_skip_on_advance_bytes;
      if ((m_buffer_len + len) >= m_buffer_len_max) {
	// realloc
	m_buffer_len_max = m_buffer_len + len + 1024;
	m_buffer = (uint8_t *)realloc(m_buffer, m_buffer_len_max);
      }
      memcpy(m_buffer + m_buffer_len, 
	     from,
	     len);
      m_buffer_len += len;
      if (rpak->rtp_pak_m == 1) {
	finished = 1;
      }
      set_last_seq(rpak->rtp_pak_seq);
      xfree(rpak);
    }
    m_bytes_used = 0;
    *buffer = m_buffer + m_bytes_used;
    *buflen = m_buffer_len - m_bytes_used;
#if 0
  rtp_message(LOG_DEBUG, "%s start %02x %02x %02x %02x %02x", m_name,
		  	(*buffer)[0],
		  	(*buffer)[1],
		  	(*buffer)[2],
		  	(*buffer)[3],
		  	(*buffer)[4]);
#endif
#ifdef DEBUG_RTP_FRAMES
    rtp_message(LOG_DEBUG, "%s buffer len %d", m_name, m_buffer_len);
#endif
  }
  timetick = rtp_ts_to_msec(rtp_ts, ts, m_wrap_offset);
  m_last_rtp_ts = rtp_ts;
  
  pts->msec_timestamp = timetick;
  pts->audio_freq_timestamp = m_last_rtp_ts;
  pts->audio_freq = m_timescale;
  pts->timestamp_is_pts = true;
  return (true);
}

bool CRtpByteStream::skip_next_frame (frame_timestamp_t *pts, 
				     int *hasSyncFrame,
				     uint8_t **buffer, 
				     uint32_t *buflen,
				     void **ud)
{
  uint64_t ts;
  *hasSyncFrame = -1;  // we don't know if we have a sync frame
  m_buffer_len = m_bytes_used = 0;
  if (m_head == NULL) return false;
  ts = m_head->rtp_pak_ts;
  do {
    set_last_seq(m_head->rtp_pak_seq);
    remove_packet_rtp_queue(m_head, 1);
  } while (m_head != NULL && m_head->rtp_pak_ts == ts);

  if (m_head == NULL) return false;
  init();
  m_buffer_len = m_bytes_used = 0;
  return start_next_frame(buffer, buflen, pts, ud);
}

void CRtpByteStream::used_bytes_for_frame (uint32_t bytes)
{
  m_bytes_used += bytes;
#ifdef DEBUG_RTP_FRAMES
  rtp_message(LOG_DEBUG, "%s Used %d bytes", m_name, bytes);
#endif
}

bool CRtpByteStream::have_frame (void)
{
  return find_mbit();
}

void CRtpByteStream::flush_rtp_packets (void)
{
  CRtpByteStreamBase::flush_rtp_packets();

  m_bytes_used = m_buffer_len = 0;
}


  
CAudioRtpByteStream::CAudioRtpByteStream (unsigned int rtp_pt,
					  format_list_t *fmt,
					  int ondemand,
					  uint64_t tps,
					  rtp_packet **head, 
					  rtp_packet **tail,
					  int rtp_seq_set,
					  uint16_t rtp_base_seq,
					  int rtp_ts_set,
					  uint32_t rtp_base_ts,
					  int rtcp_received,
					  uint32_t ntp_frac,
					  uint32_t ntp_sec,
					  uint32_t rtp_ts) :
  CRtpByteStream("audio", 
		 fmt,
		 rtp_pt,
		 ondemand,
		 tps,
		 head, 
		 tail,
		 rtp_seq_set, rtp_base_seq, 
		 rtp_ts_set, rtp_base_ts,
		 rtcp_received,
		 ntp_frac,
		 ntp_sec,
		 rtp_ts)
{
  init();
  m_working_pak = NULL;
}

CAudioRtpByteStream::~CAudioRtpByteStream(void)
{
}

bool CAudioRtpByteStream::have_frame (void)
{
  if (m_head == NULL) {
    if (m_working_pak != NULL && m_bytes_used < m_working_pak->rtp_data_len) {
      return true;
    }
    return false;
  }
  return true;
}

bool CAudioRtpByteStream::check_rtp_frame_complete_for_payload_type (void)
{
  return m_head != NULL;
}

void CAudioRtpByteStream::reset (void)
{
  rtp_message(LOG_DEBUG, "in audiortpreset");
  CRtpByteStream::reset();
}

void CAudioRtpByteStream::flush_rtp_packets(void) 
{
  if (m_working_pak != NULL) {
    xfree(m_working_pak);
    m_working_pak = NULL;
  }
  CRtpByteStream::flush_rtp_packets();
}
  
bool CAudioRtpByteStream::start_next_frame (uint8_t **buffer, 
					    uint32_t *buflen,
					    frame_timestamp_t *pts,
					    void **ud)
{
  uint32_t ts;
  int32_t diff;

  if (m_working_pak != NULL) {
    diff = m_working_pak->rtp_data_len - m_bytes_used;
  } else diff = 0;

  if (diff > 0) {
    // Still bytes in the buffer...
    *buffer = (uint8_t *)m_working_pak->rtp_data + m_bytes_used;
    *buflen = diff;
    pts->msec_timestamp = m_last_realtime;
    pts->audio_freq_timestamp = m_last_rtp_ts;
    pts->audio_freq = m_timescale;
    pts->timestamp_is_pts = false;
#ifdef DEBUG_RTP_FRAMES
    rtp_message(LOG_DEBUG, "%s Still left - %d bytes", m_name, *buflen);
#endif
    return true;
  } else {
    if (m_working_pak) xfree(m_working_pak);
    m_buffer_len = 0;
    m_bytes_used = m_skip_on_advance_bytes;
    m_working_pak = m_head;
    check_seq(m_working_pak->rtp_pak_seq);
    set_last_seq(m_working_pak->rtp_pak_seq);
    remove_packet_rtp_queue(m_working_pak, 0);

    *buffer = (uint8_t *)m_working_pak->rtp_data + m_bytes_used;
    *buflen = m_working_pak->rtp_data_len;
    ts = m_working_pak->rtp_pak_ts;
#ifdef DEBUG_RTP_FRAMES
    rtp_message(LOG_DEBUG, "%s buffer seq %d ts %x len %d", m_name, 
		m_working_pak->rtp_pak_seq, 
		m_working_pak->rtp_pak_ts, *buflen);
#endif
  }

  // We're going to have to handle wrap better...
  uint64_t retts = rtp_ts_to_msec(ts, 
				  m_working_pak->pd.rtp_pd_timestamp,
				  m_wrap_offset);
  
  m_last_rtp_ts = ts;
  pts->msec_timestamp = retts;
  pts->audio_freq_timestamp = m_last_rtp_ts;
  pts->audio_freq = m_timescale;
  pts->timestamp_is_pts = false;
  return true;
}