开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
sdp_encode.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：18k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

sdp_encode.c：源码内容
  1. /*
  2.  * The contents of this file are subject to the Mozilla Public
  3.  * License Version 1.1 (the "License"); you may not use this file
  4.  * except in compliance with the License. You may obtain a copy of
  5.  * the License at http://www.mozilla.org/MPL/
  6.  * 
  7.  * Software distributed under the License is distributed on an "AS
  8.  * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  9.  * implied. See the License for the specific language governing
  10.  * rights and limitations under the License.
  11.  * 
  12.  * The Original Code is MPEG4IP.
  13.  * 
  14.  * The Initial Developer of the Original Code is Cisco Systems Inc.
  15.  * Portions created by Cisco Systems Inc. are
  16.  * Copyright (C) Cisco Systems Inc. 2000, 2001.  All Rights Reserved.
  17.  * 
  18.  * Contributor(s): 
  19.  *              Bill May        wmay@cisco.com
  20.  */
  21. /*
  22.  * sdp_encode.c
  23.  *
  24.  * Encodes session_desc_t structure into an SDP file.
  25.  *
  26.  * October, 2000
  27.  * Bill May (wmay@cisco.com)
  28.  * Cisco Systems, Inc.
  29.  */
  30. #include "sdp.h"
  31. #include "sdp_decode_private.h"
  33. typedef struct sdp_encode_t {
  34.   char *buffer;
  35.   uint32_t used;
  36.   uint32_t buflen;
  37. } sdp_encode_t;
  39. static int prepare_sdp_encode (sdp_encode_t *se)
  40. {
  41.   se->buffer = malloc(2048);
  42.   if (se->buffer == NULL) return ENOMEM;
  43.   se->buffer[0] = '';
  44.   se->used = 0;
  45.   se->buflen = 2048;
  46.   return (0);
  47. }
  49. static int add_string_to_encode (sdp_encode_t *sptr, const char *buf)
  50. {
  51.   uint32_t len;
  52.   char *temp;
  53.   
  54.   if (buf == NULL) return (EINVAL);
  55.   len = strlen(buf);
  56.   if (len == 0) return (0);
  57.   
  58.   if (len + 1 + sptr->used > sptr->buflen) {
  59.     temp = realloc(sptr->buffer, sptr->buflen + 1024);
  60.     if (temp == NULL)
  61.       return (ENOMEM);
  62.     sptr->buffer = temp;
  63.     sptr->buflen += 1024;
  64.   }
  65.   strcpy(sptr->buffer + sptr->used, buf);
  66.   sptr->used += len;
  67.   return (0);
  68. }
  70. #define ADD_STR_TO_ENCODE_WITH_RETURN(se, string) 
  71.  { int ret; ret = add_string_to_encode(se, string); if (ret != 0) return(ret);}
  73. #define CHECK_RETURN(a) {int ret; ret = (a); if (ret != 0) return (ret); }
  74. static int encode_a_ints (int recvonly,
  75.    int sendrecv,
  76.    int sendonly,
  77.    sdp_encode_t *se)
  78. {
  79.   if (recvonly)
  80.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=recvonlyn");
  81.   if (sendrecv)
  82.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sendrecvn");
  83.   if (sendonly)
  84.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sendonlyn");
  86.   return(0);
  87. }
  89. static int encode_string_list (string_list_t *sptr,
  90.        sdp_encode_t *se,
  91.        char* code,
  92.        int *cnt)
  93. {
  94.   int val;
  95.   val = 0;
  96.   while (sptr != NULL) {
  97.     ADD_STR_TO_ENCODE_WITH_RETURN(se, code);
  98.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->string_val);
  99.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  100.     val++;
  101.     sptr = sptr->next;
  102.   }
  103.   if (cnt != NULL) *cnt = val;
  104.   return (0);
  105. }
  107. static int encode_bandwidth (bandwidth_t *bptr, sdp_encode_t *se)
  108. {
  109.   char buffer[20];
  110.   while (bptr != NULL) {
  111.     if (bptr->modifier == BANDWIDTH_MODIFIER_NONE)
  112.       return (0);
  113.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "b=");
  114.     ADD_STR_TO_ENCODE_WITH_RETURN(se, 
  115.   bptr->modifier == BANDWIDTH_MODIFIER_USER ? 
  116.   bptr->user_band :
  117.   bptr->modifier == BANDWIDTH_MODIFIER_CT ?
  118.      "CT" : "AS");
  119.     sprintf(buffer, ":%ldn", bptr->bandwidth);
  120.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  121.     bptr = bptr->next;
  122.   }
  123.   return (0);
  124. }
  126. static int encode_category (category_list_t *cptr, sdp_encode_t *se)
  127. {
  128.   int first;
  129.   char buffer[40];
  130.   
  131.   first = FALSE;
  132.   while (cptr != NULL) {
  133.     if (first == FALSE) {
  134.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=cat:");
  135.       sprintf(buffer, "%llu", cptr->category);
  136.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  137.       first = TRUE;
  138.     } else {
  139.       sprintf(buffer, ".%llu", cptr->category);
  140.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  141.     }
  142.     cptr = cptr->next;
  143.   }
  144.   if (first == TRUE)
  145.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  146.   return(0);
  147. }
  149. static int encode_conf_type (session_desc_t *sptr, sdp_encode_t *se)
  150. {
  151.   const char *temp;
  152.   switch (sptr->conf_type) {
  153.   case CONFERENCE_TYPE_NONE:
  154.   default:
  155.     return (0);
  156.   case CONFERENCE_TYPE_OTHER:
  157.     temp = sptr->conf_type_user;
  158.     break;
  159.   case CONFERENCE_TYPE_BROADCAST:
  160.     temp = "broadcast";
  161.     break;
  162.   case CONFERENCE_TYPE_MEETING:
  163.     temp = "meeting";
  164.     break;
  165.   case CONFERENCE_TYPE_MODERATED:
  166.     temp = "moderated";
  167.     break;
  168.   case CONFERENCE_TYPE_TEST:
  169.     temp = "test";
  170.     break;
  171.   case CONFERENCE_TYPE_H332:
  172.     temp = "H322";
  173.     break;
  174.   }
  175.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=type:");
  176.   ADD_STR_TO_ENCODE_WITH_RETURN(se, temp);
  177.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  178.   return (0);
  179. }
  181. static int encode_connect (connect_desc_t *cptr, sdp_encode_t *se)
  182. {
  183.   char buffer[20];
  184.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "c=IN ");
  185.   ADD_STR_TO_ENCODE_WITH_RETURN(se, cptr->conn_type);
  186.   ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  187.   ADD_STR_TO_ENCODE_WITH_RETURN(se, cptr->conn_addr);
  188.   if (cptr->ttl) {
  189.     sprintf(buffer, "/%d", cptr->ttl);
  190.     ADD_STR_TO_ENCODE_WITH_RETURN(se,buffer);
  191.     if (cptr->num_addr) {
  192.       sprintf(buffer, "/%d", cptr->num_addr);
  193.       ADD_STR_TO_ENCODE_WITH_RETURN(se,buffer);
  194.     }
  195.   }
  196.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  197.   return (0);
  198. }
  200. static int encode_key (key_desc_t *kptr, sdp_encode_t *se)
  201. {
  202.   const char *temp;
  203.   
  204.   switch (kptr->key_type) {
  205.   case KEY_TYPE_NONE:
  206.   default:
  207.     return (0);
  208.   case KEY_TYPE_PROMPT:
  209.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "k=promptn");
  210.     return(0);
  211.   case KEY_TYPE_CLEAR:
  212.     temp ="clear";
  213.     break;
  214.   case KEY_TYPE_BASE64:
  215.     temp = "base64";
  216.     break;
  217.   case KEY_TYPE_URI:
  218.     temp = "uri";
  219.     break;
  220.   }
  221.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "k=");
  222.   ADD_STR_TO_ENCODE_WITH_RETURN(se, temp);
  223.   ADD_STR_TO_ENCODE_WITH_RETURN(se, ":");
  224.   ADD_STR_TO_ENCODE_WITH_RETURN(se, kptr->key);
  225.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  226.   return (0);
  227. }
  228. static int encode_range (range_desc_t *rptr, sdp_encode_t *se)
  229. {
  230.   char buffer[80];
  231.   if (rptr->have_range) {
  232.     if (rptr->range_is_npt) {
  233.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=npt:");
  234.       sprintf(buffer, "%g-", rptr->range_start);
  235.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  236.       if (rptr->range_end_infinite == FALSE) {
  237. sprintf(buffer,"%g", rptr->range_end);
  238. ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  239.       }
  240.     } else {
  241.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=smpte");
  242.       if (rptr->range_smpte_fps != 0) {
  243. sprintf(buffer, "-%d", rptr->range_smpte_fps);
  244. ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  245.       }
  246.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "=");
  247.       sdp_smpte_to_str(rptr->range_start, rptr->range_smpte_fps, buffer);
  248.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  249.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "-");
  250.       if (rptr->range_end_infinite == FALSE) {
  251. sdp_smpte_to_str(rptr->range_end, rptr->range_smpte_fps, buffer);
  252. ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  253.       }
  254.     }
  255.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  256.   }
  257.   return (0);
  258. }
  260. static int encode_time (session_time_desc_t *tptr, sdp_encode_t *se)
  261. {
  262.   uint64_t start, end;
  263.   time_repeat_desc_t *rptr;
  264.   uint32_t ix;
  265.   char buffer[80];
  266.   
  267.   while (tptr != NULL) {
  268.     start = tptr->start_time;
  269.     if (start != 0) start += NTP_TO_UNIX_TIME;
  270.     end = tptr->end_time;
  271.     if (end != 0) end += NTP_TO_UNIX_TIME;
  273.     sprintf(buffer, "t=%llu %llun", start, end);
  274.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  276.     rptr = tptr->repeat;
  277.     while (rptr != NULL) {
  278.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "r=");
  279.       sdp_time_offset_to_str(rptr->repeat_interval, buffer, sizeof(buffer));
  280.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  281.       ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  282.       sdp_time_offset_to_str(rptr->active_duration, buffer, sizeof(buffer));
  283.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  284.       for (ix = 0; ix < rptr->offset_cnt; ix++) {
  285. sprintf(buffer, " %d", rptr->offsets[ix]);
  286. ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  287.       }
  288.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  289.       rptr = rptr->next;
  290.     }
  291.     tptr = tptr->next;
  292.   }
  293.   return (0);
  294. }
  296. static int encode_time_adj (time_adj_desc_t *aptr, sdp_encode_t *se)
  297. {
  298.   uint64_t time;
  299.   uint32_t offset;
  300.   uint32_t len;
  301.   char buffer[40], *buff;
  302.   int dohead;
  304.   if (aptr == NULL) return (0);
  305.   
  306.   dohead = TRUE;
  307.   while (aptr != NULL) {
  308.     ADD_STR_TO_ENCODE_WITH_RETURN(se, dohead ? "z=" : " ");
  309.     time = aptr->adj_time + NTP_TO_UNIX_TIME;
  310.     sprintf(buffer, "%llu ", time);
  311.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  312.     if (aptr->offset < 0) {
  313.       offset = (0 - aptr->offset);
  314.       buffer[0] = '-';
  315.       buff = &buffer[1];
  316.       len = sizeof(buffer) - 1;
  317.     } else {
  318.       offset = aptr->offset;
  319.       buff = buffer;
  320.       len = sizeof(buffer);
  321.     }
  322.     sdp_time_offset_to_str(offset, buff, len);
  323.     
  324.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  325.     if (dohead == FALSE)
  326.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  327.     dohead = !dohead;
  328.     aptr = aptr->next;
  329.   }
  330.   if (dohead == FALSE)
  331.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  332.   return (0);
  333. }
  335. static int encode_orient (media_desc_t *mptr, sdp_encode_t *se)
  336. {
  337.   const char *temp;
  338.   switch (mptr->orient_type) {
  339.   case ORIENT_TYPE_NONE:
  340.   default:
  341.     return (0);
  342.     
  343.   case ORIENT_TYPE_PORTRAIT:
  344.     temp = "portrait";
  345.     break;
  346.   case ORIENT_TYPE_LANDSCAPE:
  347.     temp = "landscape";
  348.     break;
  349.   case ORIENT_TYPE_SEASCAPE:
  350.     temp = "seascape";
  351.     break;
  352.   case ORIENT_TYPE_USER:
  353.     temp = mptr->orient_user_type;
  354.     break;
  355.   }
  356.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=orient:");
  357.   ADD_STR_TO_ENCODE_WITH_RETURN(se, temp);
  358.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  359.   return(0);
  360. }
  362. static int encode_media (media_desc_t *mptr, sdp_encode_t *se)
  363. {
  364.   format_list_t *fptr;
  365.   char buffer[80];
  366.   
  367.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "m=");
  368.   ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->media);
  369.   
  370.   sprintf(buffer, " %u", mptr->port);
  371.   ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  372.   if (mptr->num_ports) {
  373.     sprintf(buffer,"/%u", mptr->num_ports);
  374.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  375.   }
  376.   ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  377.   ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->proto);
  379.   fptr = mptr->fmt;
  380.   while (fptr != NULL) {
  381.     ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  382.     ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
  383.     fptr = fptr->next;
  384.   }
  385.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  386.   if (mptr->media_desc) {
  387.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "i=");
  388.     ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->media_desc);
  389.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  390.   }
  391.   if (mptr->media_connect.used) {
  392.     CHECK_RETURN(encode_connect(&mptr->media_connect, se));
  393.   }
  394.   CHECK_RETURN(encode_bandwidth(mptr->media_bandwidth, se));
  395.   CHECK_RETURN(encode_key(&mptr->key, se));
  396.   
  397.   if (mptr->ptime_present) {
  398.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=ptime:");
  399.     sprintf(buffer, "%un", mptr->ptime);
  400.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  401.   }
  402.   if (mptr->quality_present) {
  403.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=quality:");
  404.     sprintf(buffer, "%un", mptr->quality);
  405.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  406.   }
  407.   if (mptr->framerate_present) {
  408.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=framerate:");
  409.     sprintf(buffer, "%gn", mptr->framerate);
  410.     ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  411.   }
  412.   
  413.   if (mptr->control_string) {
  414.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=control:");
  415.     ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->control_string);
  416.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  417.   }
  418.   if (mptr->sdplang) {
  419.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sdplang:");
  420.     ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->sdplang);
  421.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  422.   }
  423.   if (mptr->lang) {
  424.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=lang:");
  425.     ADD_STR_TO_ENCODE_WITH_RETURN(se, mptr->lang);
  426.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  427.   }
  429.   fptr = mptr->fmt;
  430.   while (fptr != NULL) {
  431.     if (fptr->rtpmap != NULL) {
  432.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=rtpmap:");
  433.       ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
  434.       ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  435.       ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->rtpmap->encode_name);
  436.       sprintf(buffer, "/%u", fptr->rtpmap->clock_rate);
  437.       ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  438.       if (fptr->rtpmap->encode_param != 0) {
  439. sprintf(buffer, "/%u", fptr->rtpmap->encode_param);
  440. ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  441.       }
  442.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  443.     }
  444.     if (fptr->fmt_param != NULL) {
  445.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=fmtp:");
  446.       ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt);
  447.       ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  448.       ADD_STR_TO_ENCODE_WITH_RETURN(se, fptr->fmt_param);
  449.       ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  450.     }
  451.     fptr = fptr->next;
  452.   }
  453.   CHECK_RETURN(encode_a_ints(mptr->recvonly,
  454.       mptr->sendrecv,
  455.       mptr->sendonly,
  456.       se));
  457.   CHECK_RETURN(encode_orient(mptr, se));
  458.   CHECK_RETURN(encode_range(&mptr->media_range, se));
  459.   CHECK_RETURN(encode_string_list(mptr->unparsed_a_lines, se, "", NULL));
  460.   return (0);
  461. } 
  462.   
  463. static int sdp_encode (session_desc_t *sptr, sdp_encode_t *se)
  464. {
  465.   int temp, temp1;
  466.   media_desc_t *mptr;
  467.   char buffer[80];
  469.   if (sptr->create_addr_type == NULL ||
  470.       sptr->create_addr == NULL) {
  471.     return (ESDP_ORIGIN);
  472.   }
  473.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "v=0no=");
  474.   ADD_STR_TO_ENCODE_WITH_RETURN(se,
  475. sptr->orig_username == NULL ?
  476. "-" : sptr->orig_username);
  477.   sprintf(buffer, " %lld %lld IN ",
  478.   sptr->session_id,
  479.   sptr->session_version);
  480.   ADD_STR_TO_ENCODE_WITH_RETURN(se, buffer);
  481.   ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr_type);
  482.   ADD_STR_TO_ENCODE_WITH_RETURN(se, " ");
  483.   ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->create_addr);
  484.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "ns=");
  485.   ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_name);
  486.   ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  488.   if (sptr->session_desc != NULL) {
  489.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "i=");
  490.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->session_desc);
  491.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  492.   }
  493.   if (sptr->uri != NULL) {
  494.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
  495.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
  496.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  497.   }
  498.   CHECK_RETURN(encode_string_list(sptr->admin_email, se, "e=", &temp));
  499.   CHECK_RETURN(encode_string_list(sptr->admin_phone, se, "p=", &temp1));
  500.   if (temp + temp1 == 0) {
  501.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "e=NONEn");
  502.   }
  503.   if (sptr->session_connect.used) {
  504.     CHECK_RETURN(encode_connect(&sptr->session_connect, se));
  505.   }
  506.   CHECK_RETURN(encode_bandwidth(sptr->session_bandwidth, se));
  507.   CHECK_RETURN(encode_time(sptr->time_desc, se));
  508.   CHECK_RETURN(encode_time_adj(sptr->time_adj_desc, se));
  509.   CHECK_RETURN(encode_key(&sptr->key, se));
  510.   if (sptr->control_string) {
  511.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=control:");
  512.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->control_string);
  513.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  514.   }
  515.   CHECK_RETURN(encode_category(sptr->category_list, se));
  516.   if (sptr->keywds) {
  517.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "u=");
  518.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->uri);
  519.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  520.   }
  521.   CHECK_RETURN(encode_conf_type(sptr, se));
  522.   if (sptr->tool) {
  523.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=tool:");
  524.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->tool);
  525.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  526.   }
  527.   if (sptr->charset) {
  528.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=charset:");
  529.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->charset);
  530.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  531.   }
  532.   if (sptr->sdplang) {
  533.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=sdplang:");
  534.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->sdplang);
  535.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  536.   }
  537.   if (sptr->lang) {
  538.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=lang:");
  539.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->lang);
  540.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  541.   }
  543.   if (sptr->etag) {
  544.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "a=etag:");
  545.     ADD_STR_TO_ENCODE_WITH_RETURN(se, sptr->etag);
  546.     ADD_STR_TO_ENCODE_WITH_RETURN(se, "n");
  547.   }
  548.   
  549.   CHECK_RETURN(encode_range(&sptr->session_range, se));
  550.   CHECK_RETURN(encode_a_ints(sptr->recvonly,
  551.       sptr->sendrecv,
  552.       sptr->sendonly,
  553.       se));
  554.   CHECK_RETURN(encode_string_list(sptr->unparsed_a_lines, se, "", NULL));
  555.   mptr = sptr->media;
  556.   while (mptr != NULL) {
  557.     CHECK_RETURN(encode_media(mptr, se));
  558.     mptr = mptr->next;
  559.   }
  560.   return (0);
  561. }  
  562.   
  563. int sdp_encode_one_to_file (session_desc_t *sptr,
  564.     const char *filename,
  565.     int append)
  566. {
  567.   FILE *ofile;
  568.   sdp_encode_t sdp;
  569.   CHECK_RETURN(prepare_sdp_encode(&sdp));
  570.   CHECK_RETURN(sdp_encode(sptr, &sdp));
  571.   ofile = fopen(filename, append ? "a" : "w");
  572.   if (ofile == NULL) {
  573.     free(sdp.buffer);
  574. return (-1);
  575.   }
  576.   fputs(sdp.buffer, ofile);
  577.   fclose(ofile);
  578.   free(sdp.buffer);
  579.   return (0);
  580. }
  582. int sdp_encode_list_to_file (session_desc_t *sptr,
  583.       const char *filename,
  584.       int append)
  585. {
  586.   FILE *ofile;
  587.   sdp_encode_t sdp;
  588.   int ret;
  589.   
  590.   CHECK_RETURN(prepare_sdp_encode(&sdp));
  591.   ofile = fopen(filename, append ? "a" : "w");
  592.   if (ofile == NULL) {
  593.     free(sdp.buffer);
  594. return (-1);
  595.   }
  596.   while (sptr != NULL) {
  597.     sdp.used = 0;
  598.     ret = sdp_encode(sptr, &sdp);
  599.     if (ret != 0) {
  600.       break;
  601.     }
  602.     fputs(sdp.buffer, ofile);
  603.     sptr = sptr->next;
  604.   }
  605.   fclose(ofile);
  606.   free(sdp.buffer);
  607.   return (0);
  608. }
  610. int sdp_encode_one_to_memory (session_desc_t *sptr, char **mem)
  611. {
  612.   sdp_encode_t sdp;
  613.   int ret;
  614.   
  615.   *mem = NULL;
  616.   CHECK_RETURN(prepare_sdp_encode(&sdp));
  617.   ret = sdp_encode(sptr, &sdp);
  618.   if (ret != 0) {
  619.     free(sdp.buffer);
  620.     return (ret);
  621.   }
  622.   *mem = sdp.buffer;
  623.   return (0);
  624. }
  626. int sdp_encode_list_to_memory (session_desc_t *sptr, char **mem, int *count)
  627. {
  628.   sdp_encode_t sdp;
  629.   int ret;
  630.   int cnt;
  631.   
  632.   *mem = NULL;
  633.   CHECK_RETURN(prepare_sdp_encode(&sdp));
  634.   cnt = 0;
  635.   ret = 0;
  636.   while (sptr != NULL && ret == 0) {
  637.     ret = sdp_encode(sptr, &sdp);
  638.     if (ret == 0)
  639.       cnt++;
  640.     sptr = sptr->next;
  641.   }
  642.   *mem = sdp.buffer;
  643.   if (count != NULL)
  644.     *count = cnt;
  645.   return (ret);
  646. }