real.cpp

本源码包

/*
 *
 *
 *
 *
 */

#include	"real.h"
#include	"sdp.h"
#include	"rmff.h"


#ifndef	MAX
#define	MAX(a, b)	((a) > (b) ? (a) : (b))
#endif



/*
 * looking at stream description.
 */

rmff_header_t *real_parse_sdp(FILE *rfile) 
{
  	sdp_t *desc;
  	rmff_header_t *header;
  	char buf[2048], data[1024];
  	int len, i;
  	int max_bit_rate=0;
  	int avg_bit_rate=0;
  	int max_packet_size=0;
  	int avg_packet_size=0;
  	int duration=0;
  

  	if (!rfile) return NULL;

  	desc=sdp_parse(rfile);

  	if (!desc) return NULL;
  
  	header = new rmff_header_t;
  	header->fileheader = rmff_new_fileheader(4+desc->stream_count);
  
	header->cont=rmff_new_cont(\
      desc->title,\
      desc->author,\
      desc->copyright,\
      desc->abstract);
  	header->data = rmff_new_dataheader(0,0);
  	header->streams  = new rmff_pmdpr_t[desc->stream_count+1];

	for(int i = 0; i < desc -> stream_count; i ++)
	{
		header -> streams[i] = NULL;
		header -> streams[i + 1] = NULL;

  		header -> streams[i] = rmff_new_mdpr(\
		desc -> stream[i] -> stream_id,\
        	desc -> stream[i] -> max_bit_rate,\
       	 	desc -> stream[i] -> avg_bit_rate,\
        	desc -> stream[i] -> max_packet_size,\
        	desc -> stream[i] -> avg_packet_size,\
       	 	desc -> stream[i] -> start_time,\
        	desc -> stream[i] -> preroll,\
        	desc -> stream[i] -> duration,\
        	desc -> stream[i] -> stream_name,\
        	desc -> stream[i] -> mime_type,\
			desc -> stream[i] -> opaque_data_size,\
			desc -> stream[i] -> opaque_data);

    	duration = MAX(duration,desc -> stream[i] -> duration);
    	max_bit_rate = max_bit_rate + desc -> stream[i] -> max_bit_rate;
    	avg_bit_rate = avg_bit_rate + desc -> stream[i] -> max_bit_rate;
    	
		max_packet_size = MAX(max_packet_size, desc -> stream[i] -> \
				max_packet_size);
		avg_packet_size = MAX(avg_packet_size, desc -> stream[i] -> \
				avg_packet_size);
  	}
	
  
  	header->prop=rmff_new_prop(\
      	max_bit_rate,\
     	avg_bit_rate,\
      	max_packet_size,\
      	avg_packet_size,\
      	0,\
      	duration,\
      	0,\
      	0,\
      	0,\
      	desc->stream_count,\
      	desc->flags);

  	rmff_fix_header(header);
	sdp_free(desc);
  	return header;
}










/*
int real_get_rdt_chunk(rtsp_t *rtsp_session, char *buffer) {

  int n=1;
  uint8_t header[8];
  rmff_pheader_t ph;
  int size;
  int flags1;
  int unknown1;
  uint32_t ts;

  n=rtsp_read_data(rtsp_session, header, 8);
  if (n<8) return 0;
  if (header[0] != 0x24)
  {
    printf("rdt chunk not recognized: got 0x%02x\n", header[0]);
    return 0;
  }
  size=(header[1]<<12)+(header[2]<<8)+(header[3]);
  flags1=header[4];
  if ((flags1!=0x40)&&(flags1!=0x42))
  {

    header[0]=header[5];
    header[1]=header[6];
    header[2]=header[7];
    n=rtsp_read_data(rtsp_session, header+3, 5);
    if (n<5) return 0;

    n=rtsp_read_data(rtsp_session, header+4, 4);
    if (n<4) return 0;
    flags1=header[4];
    size-=9;
  }
  unknown1=(header[5]<<12)+(header[6]<<8)+(header[7]);
  n=rtsp_read_data(rtsp_session, header, 6);
  if (n<6) return 0;
  ts=BE_32(header);
 
  size+=2;
  
  ph.object_version=0;
  ph.length=size;
  ph.stream_number=(flags1>>1)&1;
  ph.timestamp=ts;
  ph.reserved=0;
  ph.flags=0;      // TODO: determine keyframe flag and insert here? 
  rmff_dump_pheader(&ph, buffer);
  size-=12;
  n=rtsp_read_data(rtsp_session, buffer+12, size);
  
  return n+12;
}
*/

/*
rmff_header_t  *real_setup_and_get_header(rtsp_t *rtsp_session, uint32_t bandwidth) {

  char *description=NULL;
  char *session_id=NULL;
  rmff_header_t *h;
  char *challenge1;
  char challenge2[64];
  char checksum[34];
  char subscribe[256];
  char buf[256];
  char *mrl=rtsp_get_mrl(rtsp_session);
  unsigned int size;
  int status;
  
  // get challenge 
  challenge1=strdup(rtsp_search_answers(rtsp_session,"RealChallenge1"));

  // request stream description 
  rtsp_schedule_field(rtsp_session, "Accept: application/sdp");
  sprintf(buf, "Bandwidth: %u", bandwidth);
  rtsp_schedule_field(rtsp_session, buf);
  rtsp_schedule_field(rtsp_session, "Require: com.real.retain-entity-for-setup");
  status=rtsp_request_describe(rtsp_session,NULL);

  if ( status<200 || status>299 )
  {
    char *alert=rtsp_search_answers(rtsp_session,"Alert");
    if (alert) {
      printf("real: got message from server:\n%s\n", alert);
    }
    rtsp_send_ok(rtsp_session);
    return NULL;
  }

  // receive description 
  size=0;
  if (!rtsp_search_answers(rtsp_session,"Content-length"))
    printf("real: got no Content-length!\n");
  else
    size=atoi(rtsp_search_answers(rtsp_session,"Content-length"));

  if (!rtsp_search_answers(rtsp_session,"ETag"))
    printf("real: got no ETag!\n");
  else
    session_id=strdup(rtsp_search_answers(rtsp_session,"ETag"));

  description=malloc(sizeof(char)*(size+1));

  rtsp_read_data(rtsp_session, description, size);
  description[size]=0;

  // parse sdp (sdpplin) and create a header and a subscribe string 
  strcpy(subscribe, "Subscribe: ");
  h=real_parse_sdp(description, subscribe+11, bandwidth);
  rmff_fix_header(h);

  // setup our streams 
  real_calc_response_and_checksum (challenge2, checksum, challenge1);
  sprintf(buf, "RealChallenge2: %s, sd=%s", challenge2, checksum);
  rtsp_schedule_field(rtsp_session, buf);
  sprintf(buf, "If-Match: %s", session_id);
  rtsp_schedule_field(rtsp_session, buf);
  rtsp_schedule_field(rtsp_session, \
  		"Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play");
  sprintf(buf, "%s/streamid=0", mrl);
  rtsp_request_setup(rtsp_session,buf);

  if (h->prop->num_streams > 1) 
  {
    rtsp_schedule_field(rtsp_session, \
    	"Transport: x-pn-tng/tcp;mode=play,rtp/avp/tcp;unicast;mode=play");
    sprintf(buf, "If-Match: %s", session_id);
    rtsp_schedule_field(rtsp_session, buf);

    sprintf(buf, "%s/streamid=1", mrl);
    rtsp_request_setup(rtsp_session,buf);
  }
  // set stream parameter (bandwidth) with our subscribe string 
  rtsp_schedule_field(rtsp_session, subscribe);
  rtsp_request_setparameter(rtsp_session,NULL);

  // and finally send a play request 
  rtsp_schedule_field(rtsp_session, "Range: npt=0-");
  rtsp_request_play(rtsp_session,NULL);

  return h;
}
*/