sdp_encode.c

完整的RTP RTSP代码库

      buffer[0] = '-';
      buff = &buffer[1];
      len = sizeof(buffer) - 1;
    } else {
      offset = aptr->offset;
      buff = buffer;
      len = sizeof(buffer);
    }
    sdp_time_offset_to_str(offset, buff, len);
    
    ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
    if (dohead == FALSE)
      ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
    dohead = !dohead;
    aptr = aptr->next;
  }
  if (dohead == FALSE)
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  return (0);
}

static int encode_orient (media_desc_t *mptr, sdp_encode_t *se)
{
  const char *temp;
  switch (mptr->orient_type) {
  case ORIENT_TYPE_NONE:
  default:
    return (0);
    
  case ORIENT_TYPE_PORTRAIT:
    temp = "portrait";
    break;
  case ORIENT_TYPE_LANDSCAPE:
    temp = "landscape";
    break;
  case ORIENT_TYPE_SEASCAPE:
    temp = "seascape";
    break;
  case ORIENT_TYPE_USER:
    temp = mptr->orient_user_type;
    break;
  }
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=orient:");
  ADD_STR_TO_ENCODE_WITH_RETURN(se, temp);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  return(0);
}

static int encode_media (media_desc_t *mptr, sdp_encode_t *se)
{
  format_list_t *fptr;
  char buffer[80];
  
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "m=");
  ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->media);
  
  snprintf(buffer, sizeof(buffer), " %u", mptr->port);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  if (mptr->num_ports) {
    snprintf(buffer,sizeof(buffer), "/%u", mptr->num_ports);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  }
  ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->proto);

  fptr = mptr->fmt_list;
  while (fptr != NULL) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
    fptr = fptr->next;
  }
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  if (mptr->media_desc) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "i=");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->media_desc);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (mptr->media_connect.used) {
    CHECK_RETURN(encode_connect(&mptr->media_connect, se));
  }
  if (mptr->rtcp_connect.used) {
    CHECK_RETURN(encode_rtcp(mptr, se));
  }
  CHECK_RETURN(encode_bandwidth(mptr->media_bandwidth, se));
  CHECK_RETURN(encode_key(&mptr->key, se));
  
  if (mptr->ptime_present) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=ptime:");
    snprintf(buffer, sizeof(buffer), "%u\n", mptr->ptime);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  }
  if (mptr->quality_present) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=quality:");
    snprintf(buffer, sizeof(buffer), "%u\n", mptr->quality);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  }
  if (mptr->framerate_present) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=framerate:");
    snprintf(buffer, sizeof(buffer), "%g\n", mptr->framerate);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  }
  
  if (mptr->control_string) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=control:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->control_string);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (mptr->sdplang) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sdplang:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->sdplang);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (mptr->lang) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=lang:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->lang);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }

  fptr = mptr->fmt_list;
  while (fptr != NULL) {
    if (fptr->rtpmap_name != NULL) {
      ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=rtpmap:");
      ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
      ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
      ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->rtpmap_name);
      snprintf(buffer, sizeof(buffer), "/%u", fptr->rtpmap_clock_rate);
      ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
      if (fptr->rtpmap_encode_param != 0) {
	snprintf(buffer, sizeof(buffer), "/%u", fptr->rtpmap_encode_param);
	ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
      }
      ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
    }
    if (fptr->fmt_param != NULL) {
      ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=fmtp:");
      ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
      ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
      ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt_param);
      ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
    }
    fptr = fptr->next;
  }
  CHECK_RETURN(encode_a_ints(mptr->recvonly,
			      mptr->sendrecv,
			      mptr->sendonly,
			      se));
  CHECK_RETURN(encode_orient(mptr, se));
  CHECK_RETURN(encode_range(&mptr->media_range, se));
  CHECK_RETURN(encode_string_list(mptr->unparsed_a_lines, se, "", NULL));
  return (0);
} 
  
static int sdp_encode (session_desc_t *sptr, sdp_encode_t *se)
{
  int temp, temp1;
  media_desc_t *mptr;
  char buffer[80];

  if (sptr->create_addr_type == NULL ||
      sptr->create_addr == NULL) {
    return (ESDP_ORIGIN);
  }
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "v=0\no=");
  ADD_STR_TO_ENCODE_WITH_RETURN(se,
				sptr->orig_username == NULL ?
				"-" : sptr->orig_username);
  snprintf(buffer, sizeof(buffer), " "D64" "D64" IN ",
	  sptr->session_id,
	  sptr->session_version);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr_type);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "\ns=");
  ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_name);
  ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");

  if (sptr->session_desc != NULL) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "i=");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_desc);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (sptr->uri != NULL) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  CHECK_RETURN(encode_string_list(sptr->admin_email, se, "e=", &temp));
  CHECK_RETURN(encode_string_list(sptr->admin_phone, se, "p=", &temp1));
  if (temp + temp1 == 0 && sptr->no_admin_or_phone == FALSE) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "e=NONE\n");
  }
  if (sptr->session_connect.used) {
    CHECK_RETURN(encode_connect(&sptr->session_connect, se));
  }
  CHECK_RETURN(encode_bandwidth(sptr->session_bandwidth, se));
  CHECK_RETURN(encode_time(sptr->time_desc, se));
  CHECK_RETURN(encode_time_adj(sptr->time_adj_desc, se));
  CHECK_RETURN(encode_key(&sptr->key, se));
  if (sptr->control_string) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=control:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->control_string);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  CHECK_RETURN(encode_category(sptr->category_list, se));
  if (sptr->keywds) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  CHECK_RETURN(encode_conf_type(sptr, se));
  if (sptr->tool) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=tool:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->tool);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (sptr->charset) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=charset:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->charset);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (sptr->sdplang) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sdplang:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->sdplang);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  if (sptr->lang) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=lang:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->lang);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }

  if (sptr->etag) {
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=etag:");
    ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->etag);
    ADD_STR_TO_ENCODE_WITH_RETURN(se, "\n");
  }
  
  CHECK_RETURN(encode_range(&sptr->session_range, se));
  CHECK_RETURN(encode_a_ints(sptr->recvonly,
			      sptr->sendrecv,
			      sptr->sendonly,
			      se));
  CHECK_RETURN(encode_string_list(sptr->unparsed_a_lines, se, "", NULL));
  mptr = sptr->media;
  while (mptr != NULL) {
    CHECK_RETURN(encode_media(mptr, se));
    mptr = mptr->next;
  }
  return (0);
}  
	  
int sdp_encode_one_to_file (session_desc_t *sptr,
			    const char *filename,
			    int append)
{
  FILE *ofile;
  sdp_encode_t sdp;
  CHECK_RETURN(prepare_sdp_encode(&sdp));
  CHECK_RETURN(sdp_encode(sptr, &sdp));
  ofile = fopen(filename, append ? "a" : "w");
  if (ofile == NULL) {
    sdp_debug(LOG_EMERG, "Cannot open file %s", filename);
    free(sdp.buffer);
    return (-1);
  }
  fputs(sdp.buffer, ofile);
  fclose(ofile);
  free(sdp.buffer);
  return (0);
}

int sdp_encode_list_to_file (session_desc_t *sptr,
			      const char *filename,
			      int append)
{
  FILE *ofile;
  sdp_encode_t sdp;
  int retval;
  
  CHECK_RETURN(prepare_sdp_encode(&sdp));
  ofile = fopen(filename, append ? "a" : "w");
  if (ofile == NULL) {
    free(sdp.buffer);
	return (-1);
  }
  while (sptr != NULL) {
    sdp.used = 0;
    retval = sdp_encode(sptr, &sdp);
    if (retval != 0) {
      break;
    }
    fputs(sdp.buffer, ofile);
    sptr = sptr->next;
  }
  fclose(ofile);
  free(sdp.buffer);
  return (0);
}

int sdp_encode_one_to_memory (session_desc_t *sptr, char **mem)
{
  sdp_encode_t sdp;
  int retval;
  
  *mem = NULL;
  CHECK_RETURN(prepare_sdp_encode(&sdp));
  retval = sdp_encode(sptr, &sdp);
  if (retval != 0) {
    free(sdp.buffer);
    return (retval);
  }
  *mem = sdp.buffer;
  return (0);
}

int sdp_encode_list_to_memory (session_desc_t *sptr, char **mem, int *count)
{
  sdp_encode_t sdp;
  int retval;
  int cnt;
  
  *mem = NULL;
  CHECK_RETURN(prepare_sdp_encode(&sdp));
  cnt = 0;
  retval = 0;
  while (sptr != NULL && retval == 0) {
    retval = sdp_encode(sptr, &sdp);
    if (retval == 0)
      cnt++;
    sptr = sptr->next;
  }
  *mem = sdp.buffer;
  if (count != NULL)
    *count = cnt;
  return (retval);
}