hust_rtpopen.c

实现基于ip2022的MPEG2 TS的IP组播接收

/*-------------------------------------------------------------------------
 * rtpopen.c - rtpopen, rtpopensockets
 *-------------------------------------------------------------------------
 */
#include "ipOS.h"
#include "ipHAL.h"
///#include <netinet/in.h>
///#include <sys/types.h>
///#include <stdio.h>
///#include <stdlib.h>
///#include <sys/socket.h>
///#include "hust_hash.h"
///#include <strings.h>
///#include <string.h>
///#include <unistd.h>
///#include <time.h>
#include "hust_rtp.h"
#include "hust_rtcp.h"
#include "hust_util.h"
///#include <arpa/inet.h>
///#include <pthread.h>

#include "hust_rtp.h"
#include "hust_hash.h"
#include "hust_event.h"
#include "hust_rtplibcommon.h"


/*------------------------------------------------------------------------
 * rtpopen - open a new RTP session, allocate resources and create state
 *------------------------------------------------------------------------
 */
struct session *
rtpopen(u32_t session, u16_t port, u16_t bpbufsz, u8_t bpbufcnt)
{

	struct session *psn;
	bool	       rv;
	u8_t            packetsneeded;

	psn = (struct session *) heap_alloc(sizeof(struct session));
	if (psn == NULL)
		return NULL;
  
	memset(psn, 0, sizeof(struct session));

	///psn->sn_rtpfd = psn->sn_rtcpfd = -1;

	psn->sn_ssrcs = htnew(RTP_SSRCHTSZ, hashunsignedint, unsignedinteq, SSRCDESTROY);
	psn->sn_cnames = htnew(RTP_CNAMEHTSZ, hashstring, strcmp, CNAMEDESTROY);

///	psn->sn_cyclesources = (ssrc_t *) heap_alloc(sizeof(ssrc_t) * RTCP_RRMAXRBLOCKS);
	////按最大的空间分配原则，为rtcpcycle中存放ssrcs预留空间
	packetsneeded = RTCP_RRMAXRBLOCKS / RTCP_MAXRBLOCKS + ((RTCP_RRMAXRBLOCKS % RTCP_MAXRBLOCKS) != 0);
///	psn->sn_cyclebuf = (char *) heap_alloc(RTCP_RRMAXRBLOCKS * sizeof(struct rblock) + packetsneeded * (RTCP_HEADERSZ + sizeof(ssrc_t)));
	////按最大的空间分配原则，为RR包分配空间
	
///	rv = bufpoolinit(&psn->sn_bpool, bpbufsz, bpbufcnt);
  
	/*pthread_cond_init(&psn->sn_cond, NULL);
	pthread_mutex_init(&psn->sn_mutex, NULL);
	pthread_mutex_init(&psn->sn_getstreammutex, NULL);
	pthread_mutex_init(&psn->sn_cnamemutex, NULL);
	pthread_mutex_init(&psn->sn_rtpthrmutex, NULL);
	pthread_mutex_init(&psn->sn_rtcpthrmutex, NULL);
	pthread_mutex_init(&psn->sn_rtcpcyclethrmutex, NULL);*/

	psn->sn_addr = session;
	psn->sn_port = port;
	psn->sn_bw = RTP_DEFAULT_SESSIONBW;
	psn->sn_ssrc = rtpmkssrc(NULL);
	psn->sn_autocleanup = TRUE;
	//////初始化时就应该是可自动清除的。

/*	if (psn->sn_ssrcs == NULL ||
	    psn->sn_cnames == NULL ||
	    psn->sn_cyclesources == NULL ||
	    psn->sn_cyclebuf == NULL ||
	    rv == ERROR) {
		rtpclose(psn);
		return NULL;
	}
*/  
	return psn;
}
////打开一个RTP对话，分配资源，并创建会话的状态。包括的操作有：为struct session申请空间
////置rtp，rtcp文件描述标志，为stream分配新的哈希表，分配源标识描述的内存空间。以及进程
////及进程状态的初始化，赋值session的地址，端口；并打开rtp的套接字。
/*------------------------------------------------------------------------
 * rtpopensockets - open socket for RTP and RTCP datagrams
 *------------------------------------------------------------------------
 */
/*int
rtpopensockets(struct session *psn, u32_t session, int port)
{

	////struct sockaddr_in	saddr;
	u32_t	saddr;
	struct ip_mreq	        mreq;
	unsigned char		loop;
	int			reuse;
	unsigned char		ttl;

	psn->sn_rtpfd = socket(AF_INET, SOCK_DGRAM, 0);
	psn->sn_rtcpfd = socket(AF_INET, SOCK_DGRAM, 0);
  
	if (psn->sn_rtpfd < 0 || psn->sn_rtcpfd < 0) {
		return ERROR;
	}

	memset(&saddr, 0, sizeof(struct sockaddr_in));
	saddr.sin_family = AF_INET;

	if(IN_CLASSD(ntohl(session.s_addr))) {
		saddr.sin_addr = session;
	}
	else {
		saddr.sin_addr.s_addr = htonl(INADDR_ANY);
	}

	if (IN_CLASSD(ntohl(session.s_addr))) {
		reuse = 1;
		if (setsockopt(psn->sn_rtpfd, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse, sizeof(reuse)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}
    
		if (setsockopt(psn->sn_rtcpfd, SOL_SOCKET, SO_REUSEADDR, (char *) &reuse, sizeof(reuse)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}
	}
  
	saddr.sin_port = htons(port);  
	if (bind(psn->sn_rtpfd, (struct sockaddr *) &saddr, sizeof(struct sockaddr_in)) < 0) {
		close(psn->sn_rtpfd);
		close(psn->sn_rtcpfd);
		return ERROR;
	}
  
	saddr.sin_port = htons(port + 1);
	if (bind(psn->sn_rtcpfd, (struct sockaddr *) &saddr, sizeof(struct sockaddr_in)) < 0) {
		close(psn->sn_rtpfd);
		close(psn->sn_rtcpfd);
		return ERROR;
	}

	psn->sn_rtcpto = saddr;
	if (!IN_CLASSD(ntohl(session.s_addr)))
		psn->sn_rtcpto.sin_addr.s_addr = RTP_INADDRUNINITIALIZED;

	if (IN_CLASSD(ntohl(session.s_addr))) {
		mreq.imr_multiaddr = session;
		mreq.imr_interface.s_addr = htonl(INADDR_ANY);
    
		if (setsockopt(psn->sn_rtpfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof(struct ip_mreq)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}

		if (setsockopt(psn->sn_rtcpfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof(struct ip_mreq)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}*/

		/*
		 * Disable loopback on RTCP socket so we don't want to hear ourselves.
		 * This isn't done for the RTP socket because this implementation
		 * assumes no sending.
		 */
	/*	loop = 0;
		if (setsockopt(psn->sn_rtcpfd, IPPROTO_IP, IP_MULTICAST_LOOP, 
			       (char *) &loop, sizeof(loop)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}*/
    
		/* 
		 * Set TTL.
		 * This isn't done for the RTP socket because this implementation
		 * assumes no sending.
		 */
		/*ttl = RTP_DEFAULT_SESSIONTTL;
		if (setsockopt(psn->sn_rtcpfd, IPPROTO_IP, IP_MULTICAST_TTL, 
			       (char *) &ttl, sizeof(ttl)) < 0) {
			close(psn->sn_rtpfd);
			close(psn->sn_rtcpfd);
			return ERROR;
		}
	}
	return OK;
}*/