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

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

流媒体/Mpeg4/MP4

开发平台：

Visual C++

media_utils.cpp：源码内容
  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.  * media_utils.cpp - various utilities, globals (ick).
  23.  */
  24. #include <stdlib.h>
  25. #include <sdp/sdp.h>
  26. #include <libhttp/http.h>
  27. #include "media_utils.h"
  28. #include "player_session.h"
  29. #include "player_media.h"
  30. #include "codec/mp3/mp3_rtp_bytestream.h"
  31. #include "avi_file.h"
  32. #include "mp4_file.h"
  33. #include "qtime_file.h"
  34. #include "our_config_file.h"
  35. #include "rtp_bytestream.h"
  36. #include "codec/aa/isma_rtp_bytestream.h"
  37. #include "codec_plugin_private.h"
  38. #include <gnu/strcasestr.h>
  39. #include "rfc3119_bytestream.h"
  40. #include "mpeg3_rtp_bytestream.h"
  41. #include "mpeg3_file.h"
  42. #include "audio.h"
  43. #include "mpeg2t.h"
  44. /*
  45.  * This needs to be global so we can store any ports that we don't
  46.  * care about but need to reserve
  47.  */
  48. enum {
  49.   VIDEO_MPEG4_ISO,
  50.   VIDEO_DIVX,
  51.   VIDEO_MPEG4_ISO_OR_DIVX,
  52.   VIDEO_MPEG12,
  53. };
  55. enum {
  56.   MPEG4IP_AUDIO_AAC,
  57.   MPEG4IP_AUDIO_MP3,
  58.   MPEG4IP_AUDIO_WAV,
  59.   MPEG4IP_AUDIO_MPEG4_GENERIC,
  60.   MPEG4IP_AUDIO_MP3_ROBUST,
  61.   MPEG4IP_AUDIO_GENERIC,
  62. };
  63. /*
  64.  * these are lists of supported audio and video codecs
  65.  */
  66. static struct codec_list_t {
  67.   const char *name;
  68.   int val;
  69. } video_codecs[] = {
  70.   {"mp4 ", VIDEO_MPEG4_ISO},
  71.   {"mp4v", VIDEO_MPEG4_ISO},
  72.   {"MPG4", VIDEO_MPEG4_ISO},
  73.   {"MP4V-ES", VIDEO_MPEG4_ISO_OR_DIVX},
  74.   {"MPEG4-GENERIC", VIDEO_DIVX},
  75.   {"divx", VIDEO_DIVX},
  76.   {"dvx1", VIDEO_DIVX},
  77.   {"div4", VIDEO_DIVX},
  78.   {NULL, -1},
  79. },
  80.   audio_codecs[] = {
  81.     {"MPEG4-GENERIC", MPEG4IP_AUDIO_MPEG4_GENERIC},
  82.     {"MPA", MPEG4IP_AUDIO_MP3 },
  83.     {"mpa-robust", MPEG4IP_AUDIO_MP3_ROBUST}, 
  84.     {"L16", MPEG4IP_AUDIO_GENERIC },
  85.     {"L8", MPEG4IP_AUDIO_GENERIC },
  86.     {NULL, -1},
  87.   };
  91. static int lookup_codec_by_name (const char *name,
  92.  struct codec_list_t *codec_list)
  93. {
  94.   for (struct codec_list_t *cptr = codec_list; cptr->name != NULL; cptr++) {
  95.     if (strcasecmp(name, cptr->name) == 0) {
  96.       return (cptr->val);
  97.     }
  98.   }
  99.   return (-1);
  100. }
  101.   
  102. int lookup_audio_codec_by_name (const char *name)
  103. {
  104.   return (lookup_codec_by_name(name, audio_codecs));
  105. }
  107. int lookup_video_codec_by_name (const char *name)
  108. {
  109.   return (lookup_codec_by_name(name, video_codecs));
  110. }
  113. static int create_media_from_sdp (CPlayerSession *psptr,
  114.   const char *name,
  115.   session_desc_t *sdp,
  116.   char *errmsg,
  117.   uint32_t errlen,
  118.   int have_audio_driver,
  119.   int broadcast,
  120.   control_callback_vft_t *cc_vft)
  121. {
  122.   int err;
  123.   int media_count = 0;
  124.   int invalid_count = 0;
  125.   int have_audio_but_no_driver = 0;
  126.   char buffer[80];
  127.   codec_plugin_t *codec;
  128.   format_list_t *fmt;
  129.   int audio_count, video_count;
  130.   int audio_offset, video_offset;
  131.   int ix;
  133.   if (sdp->session_name != NULL) {
  134.     snprintf(buffer, sizeof(buffer), "Name: %s", sdp->session_name);
  135.     psptr->set_session_desc(0, buffer);
  136.   }
  137.   if (sdp->session_desc != NULL) {
  138.     snprintf(buffer, sizeof(buffer), "Description: %s", sdp->session_desc);
  139.     psptr->set_session_desc(1, buffer);
  140.   }
  141.   if (sdp->media != NULL &&
  142.       sdp->media->next == NULL &&
  143.       strcasecmp(sdp->media->media, "video") == 0 &&
  144.       sdp->media->fmt != NULL &&
  145.       strcmp(sdp->media->fmt->fmt, "33") == 0) {
  146.     // we have a mpeg2 transport stream
  147.   }
  148.   media_desc_t *sdp_media;
  149.   audio_count = video_count = 0;
  150.   for (sdp_media = psptr->get_sdp_info()->media;
  151.        sdp_media != NULL;
  152.        sdp_media = sdp_media->next) {
  153.     if (strcasecmp(sdp_media->media, "audio") == 0) {
  154.       if (have_audio_driver == 0) {
  155. have_audio_but_no_driver = 1;
  156.       } else {
  157. audio_count++;
  158.       }
  159.     } else if (strcasecmp(sdp_media->media, "video") == 0) {
  160.       video_count++;
  161.     }
  162.   }
  164.   video_query_t *vq;
  165.   audio_query_t *aq;
  167.   if (video_count > 0) {
  168.     vq = (video_query_t *)malloc(sizeof(video_query_t) * video_count);
  169.   } else {
  170.     vq = NULL;
  171.   }
  172.   if (audio_count > 0) {
  173.     aq = (audio_query_t *)malloc(sizeof(audio_query_t) * audio_count);
  174.   } else {
  175.     aq = NULL;
  176.   }
  177.       
  178.   video_offset = audio_offset = 0;
  179.   for (sdp_media = psptr->get_sdp_info()->media;
  180.        sdp_media != NULL;
  181.        sdp_media = sdp_media->next) {
  183.     if (have_audio_driver != 0 &&
  184. strcasecmp(sdp_media->media, "audio") == 0) {
  185.       fmt = sdp_media->fmt;
  186.       codec = NULL;
  187.       while (codec == NULL && fmt != NULL) {
  188. codec = check_for_audio_codec(NULL, 
  189.       fmt,
  190.       -1,
  191.       -1,
  192.       NULL,
  193.       0);
  194. if (codec == NULL) fmt = fmt->next;
  195.       }
  196.       if (codec == NULL) {
  197. invalid_count++;
  198. continue;
  199.       } else {
  200. // set up audio qualifier
  201. aq[audio_offset].track_id = audio_offset;
  202. aq[audio_offset].compressor = NULL;
  203. aq[audio_offset].type = -1;
  204. aq[audio_offset].profile = -1;
  205. aq[audio_offset].fptr = fmt;
  206. aq[audio_offset].sampling_freq = -1;
  207. aq[audio_offset].chans = -1;
  208. aq[audio_offset].enabled = 0;
  209. aq[audio_offset].reference = NULL;
  210. audio_offset++;
  211.       }
  212.     } else if (strcasecmp(sdp_media->media, "video") == 0) {
  213. fmt = sdp_media->fmt;
  214. codec = NULL;
  215. while (codec == NULL && fmt != NULL) {
  216.   codec = check_for_video_codec(NULL, 
  217. fmt,
  218. -1,
  219. -1,
  220. NULL,
  221. 0);
  222.   if (codec == NULL) fmt = fmt->next;
  223. }
  224. if (codec == NULL) {
  225.   invalid_count++;
  226.   continue;
  227. } else {
  228.   vq[video_offset].track_id = video_offset;
  229.   vq[video_offset].compressor = NULL;
  230.   vq[video_offset].type = -1;
  231.   vq[video_offset].profile = -1;
  232.   vq[video_offset].fptr = fmt;
  233.   vq[video_offset].h = -1;
  234.   vq[video_offset].w = -1;
  235.   vq[video_offset].frame_rate = -1;
  236.   vq[video_offset].enabled = 0;
  237.   vq[video_offset].reference = NULL;
  238.   video_offset++;
  239. }
  240.       } else {
  241. player_error_message("Skipping media type `%s'", sdp_media->media);
  242. continue;
  243.       }
  244.     }
  245.   // okay - from here, write the callback call, and go ahead...
  246.   if (cc_vft != NULL &&
  247.       cc_vft->media_list_query != NULL) {
  248.     (cc_vft->media_list_query)(psptr, video_offset, vq, audio_offset, aq);
  249.   } else {
  250.     if (video_offset > 0) {
  251.       vq[0].enabled = 1;
  252.     }
  253.     if (audio_offset > 0) {
  254.       aq[0].enabled = 1;
  255.     }
  256.   }
  257.   for (ix = 0; ix < video_offset; ix++) {
  258.     if (vq[ix].enabled != 0) {
  259.       CPlayerMedia *mptr = new CPlayerMedia(psptr);
  260.       err = mptr->create_streaming(vq[ix].fptr->media, 
  261.    errmsg, 
  262.    errlen,
  263.    broadcast, 
  264.    config.get_config_value(CONFIG_USE_RTP_OVER_RTSP),
  265.    media_count);
  266.       if (err < 0) {
  267. return (-1);
  268.       }
  269.       if (err > 0) {
  270. delete mptr;
  271.       } else 
  272. media_count++;
  273.     }
  274.   }
  275.   for (ix = 0; ix < audio_offset; ix++) {
  276.     if (aq[ix].enabled != 0) {
  277.       CPlayerMedia *mptr = new CPlayerMedia(psptr);
  278.       err = mptr->create_streaming(aq[ix].fptr->media, 
  279.    errmsg, 
  280.    errlen,
  281.    broadcast, 
  282.    config.get_config_value(CONFIG_USE_RTP_OVER_RTSP),
  283.    media_count);
  284.       if (err < 0) {
  285. return (-1);
  286.       }
  287.       if (err > 0) {
  288. delete mptr;
  289.       } else 
  290. media_count++;
  291.     }
  292.   }
  293.   if (aq != NULL) free(aq);
  294.   if (vq != NULL) free(vq);
  296.   if (media_count == 0) {
  297.     snprintf(errmsg, errlen, "No known codecs found in SDP");
  298.     return (-1);
  299.   }
  300.   psptr->streaming_media_set_up();
  301.   if (have_audio_but_no_driver > 0) {
  302.     snprintf(errmsg, errlen, "Not playing audio codecs - no driver");
  303.     return (1);
  304.   }
  305.   if (invalid_count > 0) {
  306.     snprintf(errmsg, errlen, 
  307.      "There were unknowns codecs during decode - playing valid ones");
  308.     return (1);
  309.   }
  310.   return (0);
  311. }
  312. static int create_media_for_streaming_broadcast (CPlayerSession *psptr,
  313.  const char *name,
  314.  session_desc_t *sdp,
  315.  char *errmsg,
  316.  uint32_t errlen,
  317.  int have_audio_driver,
  318.  control_callback_vft_t *cc_vft)
  319. {
  320.   int err;
  321.   // need to set range in player session...
  322.   err = psptr->create_streaming_broadcast(sdp, errmsg, errlen);
  323.   if (err != 0) {
  324.     return (-1);
  325.   }
  326.   return (create_media_from_sdp(psptr, 
  327. name, 
  328. sdp, 
  329. errmsg, 
  330. errlen,
  331. have_audio_driver, 
  332. 0,
  333. cc_vft));
  334. }
  335. /*
  336.  * create_media_for_streaming_ondemand - create streaming media session
  337.  * for an on demand program.
  338.  */
  339. static int create_media_for_streaming_ondemand (CPlayerSession *psptr, 
  340. const char *name,
  341. char *errmsg,
  342. uint32_t errlen,
  343. control_callback_vft_t *cc_vft)
  344. {
  345.   int err;
  346.   session_desc_t *sdp;
  347.   /*
  348.    * This will open the rtsp session
  349.    */
  350.   err = psptr->create_streaming_ondemand(name, 
  351.  errmsg,
  352.  errlen,
  353.  config.get_config_value(CONFIG_USE_RTP_OVER_RTSP));
  354.   if (err != 0) {
  355.     return (-1);
  356.   }
  357.   sdp = psptr->get_sdp_info();
  358.   int have_audio_driver = do_we_have_audio();
  359.   return (create_media_from_sdp(psptr,
  360. name, 
  361. sdp, 
  362. errmsg,
  363. errlen,
  364. have_audio_driver, 
  365. 1,
  366. cc_vft));
  367. }
  369. /*
  370.  * create_media_from_sdp_file - create a streaming session based on an
  371.  * sdp file.  It could be either an on-demand program (we look for the 
  372.  * url in the control string), or a broadcast.
  373.  */
  375. static int create_from_sdp (CPlayerSession *psptr,
  376.     const char *name,
  377.     char *errmsg,
  378.     uint32_t errlen,
  379.     sdp_decode_info_t *sdp_info,
  380.     int have_audio_driver,
  381.     control_callback_vft_t *cc_vft) 
  382. {
  383.   session_desc_t *sdp;
  384.   int translated;
  386.   if (sdp_info == NULL) {
  387.     strcpy(errmsg, "SDP error");
  388.     return (-1);
  389.   }
  391.   if (sdp_decode(sdp_info, &sdp, &translated) != 0) {
  392.     snprintf(errmsg, errlen, "Invalid SDP file");
  393.     sdp_decode_info_free(sdp_info);
  394.     return (-1);
  395.   }
  397.   if (translated != 1) {
  398.     snprintf(errmsg, errlen, "More than 1 program described in SDP");
  399.     sdp_decode_info_free(sdp_info);
  400.     return (-1);
  401.   }
  403.   int err;
  404.   if (sdp->control_string != NULL) {
  405.     // An on demand file... Just use the URL...
  406.     err = create_media_for_streaming_ondemand(psptr,
  407.       sdp->control_string,
  408.       errmsg,
  409.       errlen,
  410.       cc_vft);
  411.     sdp_free_session_desc(sdp);
  412.     sdp_decode_info_free(sdp_info);
  413.     return (err);
  414.   }
  415.   sdp_decode_info_free(sdp_info);
  416.   return (create_media_for_streaming_broadcast(psptr,
  417.        name, 
  418.        sdp,
  419.        errmsg,
  420.        errlen,
  421.        have_audio_driver,
  422.        cc_vft));
  423. }
  425. static int create_media_from_sdp_file(CPlayerSession *psptr, 
  426.       const char *name, 
  427.       char *errmsg,
  428.       uint32_t errlen,
  429.       int have_audio_driver,
  430.       control_callback_vft_t *cc_vft)
  431. {
  432.   sdp_decode_info_t *sdp_info;
  433.   sdp_info = set_sdp_decode_from_filename(name);
  435.   return (create_from_sdp(psptr, 
  436.   name, 
  437.   errmsg, 
  438.   errlen, 
  439.   sdp_info, 
  440.   have_audio_driver, 
  441.   cc_vft));
  442. }
  444. static int create_media_for_http (CPlayerSession *psptr,
  445.   const char *name,
  446.   char *errmsg,
  447.   uint32_t errlen,
  448.   control_callback_vft_t *cc_vft)
  449. {
  450.   http_client_t *http_client;
  452.   int ret;
  453.   http_resp_t *http_resp;
  454.   http_resp = NULL;
  455.   http_client = http_init_connection(name);
  457.   if (http_client == NULL) {
  458.     snprintf(errmsg, errlen, "Can't create http client");
  459.     return -1;
  460.   } 
  461.   ret = http_get(http_client, NULL, &http_resp);
  462.   if (ret > 0) {
  463.     sdp_decode_info_t *sdp_info;
  465.     int have_audio_driver = do_we_have_audio();
  466.     sdp_info = set_sdp_decode_from_memory(http_resp->body);
  467.     ret = create_from_sdp(psptr, 
  468.   name, 
  469.   errmsg, 
  470.   errlen, 
  471.   sdp_info, 
  472.   have_audio_driver,
  473.   cc_vft);
  474.   } else {
  475.     ret = -1;
  476.   }
  477.   http_resp_free(http_resp);
  478.   http_free_connection(http_client);
  480.   return (ret);
  481. }
  482. /*
  483.  * parse_name_for_session - look at the name, determine what routine to 
  484.  * call to set up the session.  This should be redone with plugins at
  485.  * some point.
  486.  */
  487. #define ADV_SPACE(a) {while (isspace(*(a)) && (*(a) != ''))(a)++;}
  489. int parse_name_for_session (CPlayerSession *psptr,
  490.     const char *name,
  491.     char *errmsg,
  492.     uint32_t errlen,
  493.     control_callback_vft_t *cc_vft)
  494. {
  495.   int err;
  496.   ADV_SPACE(name);
  497.   if (strncmp(name, "rtsp://", strlen("rtsp://")) == 0) {    
  498.     err = create_media_for_streaming_ondemand(psptr, 
  499.       name, 
  500.       errmsg, 
  501.       errlen,
  502.       cc_vft);
  503.     return (err);
  504.   }
  505.   if (strncmp(name, "http://", strlen("http://")) == 0) {
  506.     err = create_media_for_http(psptr, name, errmsg, errlen, cc_vft);
  507.     return (err);
  508.   }    
  509. #if 0
  510.   if (strncmp(name, "mpeg2t://", strlen("mpeg2t://")) == 0) {
  511.     err = create_mpeg2t_session(psptr, name, errmsg, errlen, cc_vft);
  512.     return (err);
  513.   }
  514. #endif
  515. #ifndef _WINDOWS
  516.   struct stat statbuf;
  517.   if (stat(name, &statbuf) != 0) {
  518.     snprintf(errmsg, errlen, "File '%s' not found", name);
  519.     return (-1);
  520.   }
  521.   if (!S_ISREG(statbuf.st_mode)) {
  522.     snprintf(errmsg, errlen, "File '%s' is not a file", name);
  523.     return (-1);
  524.   }
  525. #else
  526.   OFSTRUCT ReOpenBuff;
  527.   if (OpenFile(name, &ReOpenBuff,OF_READ) == HFILE_ERROR) {
  528.     snprintf(errmsg, errlen, "File %s not found", name);
  529.     return (-1);
  530.   }
  532. #endif
  533.   err = -1;
  535.   const char *suffix = strrchr(name, '.');
  536.   if (suffix == NULL) {
  537.     snprintf(errmsg, errlen, "No useable suffix on file %s", name);
  538.     return err;
  539.   }
  541.   int have_audio_driver;
  543.   have_audio_driver = do_we_have_audio();
  545.   if (strcasecmp(suffix, ".sdp") == 0) {
  546.     err = create_media_from_sdp_file(psptr, 
  547.      name, 
  548.      errmsg, 
  549.      errlen, 
  550.      have_audio_driver,
  551.      cc_vft);
  552.   } else if ((strcasecmp(suffix, ".mov") == 0) ||
  553.      ((config.get_config_value(CONFIG_USE_OLD_MP4_LIB) != 0) &&
  554.       (strcasecmp(suffix, ".mp4") == 0))){
  555.     err = create_media_for_qtime_file(psptr, 
  556.       name, 
  557.       errmsg, 
  558.       errlen,
  559.       have_audio_driver);
  560.   } else if (strcasecmp(suffix, ".mp4") == 0) {
  561.     err = create_media_for_mp4_file(psptr, 
  562.     name, 
  563.     errmsg, 
  564.     errlen,
  565.     have_audio_driver,
  566.     cc_vft);
  567.   } else if (strcasecmp(suffix, ".avi") == 0) {
  568.     err = create_media_for_avi_file(psptr, 
  569.     name, 
  570.     errmsg, 
  571.     errlen, 
  572.     have_audio_driver,
  573.     cc_vft);
  574.   } else if (strcasecmp(suffix, ".mpeg") == 0 ||
  575.      strcasecmp(suffix, ".mpg") == 0) {
  576.     err = create_media_for_mpeg_file(psptr, name, errmsg, 
  577.      errlen, have_audio_driver);
  578.   } else {
  579.     // raw files
  580.     if (have_audio_driver) {
  581.       err = audio_codec_check_for_raw_file(psptr, name);
  582.     }
  583.     if (err < 0) {
  584.       err = video_codec_check_for_raw_file(psptr, name);
  585.     }
  586.   }
  587.   
  588.   if (err >= 0) {
  589.     const char *temp;
  590.     temp = psptr->get_session_desc(0);
  591.     if (temp == NULL) {
  592.       psptr->set_session_desc(0, name);
  593.     }
  594.   }
  595.   return (err);
  596. }
  598.   
  599. CRtpByteStreamBase *create_rtp_byte_stream_for_format (format_list_t *fmt,
  600.        unsigned int rtp_pt,
  601.        int ondemand,
  602.        uint64_t tps,
  603.        rtp_packet **head, 
  604.        rtp_packet **tail,
  605.        int rtp_seq_set, 
  606.        uint16_t rtp_seq,
  607.        int rtp_ts_set,
  608.        uint32_t rtp_base_ts,
  609.        int rtcp_received,
  610.        uint32_t ntp_frac,
  611.        uint32_t ntp_sec,
  612.        uint32_t rtp_ts)
  613. {
  614.   CRtpByteStreamBase *rtp_byte_stream;
  616.   int codec;
  617.   if (strcmp("video", fmt->media->media) == 0) {
  618.     if (rtp_pt == 32) {
  619.       codec = VIDEO_MPEG12;
  620.       rtp_byte_stream = new CMpeg3RtpByteStream(rtp_pt,
  621. fmt, 
  622. ondemand,
  623. tps,
  624. head,
  625. tail,
  626. rtp_seq_set,
  627. rtp_seq,
  628. rtp_ts_set,
  629. rtp_base_ts,
  630. rtcp_received,
  631. ntp_frac,
  632. ntp_sec,
  633. rtp_ts);
  634.       if (rtp_byte_stream != NULL) {
  635. return (rtp_byte_stream);
  636.       }
  637.     } else {
  638.       codec = lookup_codec_by_name(fmt->rtpmap->encode_name, 
  639.    video_codecs);
  640.       if (codec < 0) {
  641. return (NULL);
  642.       }
  643.     }
  644.   } else {
  645.     if (rtp_pt == 14) {
  646.       codec = MPEG4IP_AUDIO_MP3;
  647.     } else {
  648.       codec = lookup_codec_by_name(fmt->rtpmap->encode_name, 
  649.    audio_codecs);
  650.       if (codec < 0) {
  651. return (NULL);
  652.       }
  653.     }
  654.     switch (codec) {
  655.     case MPEG4IP_AUDIO_AAC:
  656.     case MPEG4IP_AUDIO_MPEG4_GENERIC:
  657.       fmtp_parse_t *fmtp;
  659.       fmtp = parse_fmtp_for_mpeg4(fmt->fmt_param, message);
  660.       if (fmtp->size_length == 0) {
  661. // No headers in RTP packet -create normal bytestream
  662. player_debug_message("Size of AAC RTP header is 0 - normal bytestream");
  663. break;
  664.       }
  665.       rtp_byte_stream = new CIsmaAudioRtpByteStream(fmt,
  666.     fmtp,
  667.     rtp_pt,
  668.     ondemand,
  669.     tps,
  670.     head,
  671.     tail,
  672.     rtp_seq_set,
  673.     rtp_seq,
  674.     rtp_ts_set,
  675.     rtp_base_ts,
  676.     rtcp_received,
  677.     ntp_frac,
  678.     ntp_sec,
  679.     rtp_ts);
  680.       if (rtp_byte_stream != NULL) {
  681. return (rtp_byte_stream);
  682.       }
  683.       // Otherwise, create default...
  684.       break;
  685.     case MPEG4IP_AUDIO_MP3:
  686.       rtp_byte_stream = 
  687. new CMP3RtpByteStream(rtp_pt, fmt, ondemand, tps, head, tail, 
  688.       rtp_seq_set, rtp_seq,
  689.       rtp_ts_set, rtp_base_ts, 
  690.       rtcp_received, ntp_frac, ntp_sec, rtp_ts);
  691.       if (rtp_byte_stream != NULL) {
  692. player_debug_message("Starting mp3 2250 byte stream");
  693. return (rtp_byte_stream);
  694.       }
  695.       break;
  696.     case MPEG4IP_AUDIO_MP3_ROBUST:
  697.       rtp_byte_stream = 
  698. new CRfc3119RtpByteStream(rtp_pt, fmt, ondemand, tps, head, tail, 
  699.   rtp_seq_set, rtp_seq,
  700.   rtp_ts_set, rtp_base_ts, 
  701.   rtcp_received, ntp_frac, ntp_sec, rtp_ts);
  702.       if (rtp_byte_stream != NULL) {
  703. player_debug_message("Starting mpa robust byte stream");
  704. return (rtp_byte_stream);
  705.       }
  706.       break;
  707.     case MPEG4IP_AUDIO_GENERIC:
  708.       rtp_byte_stream = 
  709. new CAudioRtpByteStream(rtp_pt, fmt, ondemand, tps, head, tail, 
  710. rtp_seq_set, rtp_seq,
  711. rtp_ts_set, rtp_base_ts, 
  712. rtcp_received, ntp_frac, ntp_sec, rtp_ts);
  713.       if (rtp_byte_stream != NULL) {
  714. player_debug_message("Starting generic audio byte stream");
  715. return (rtp_byte_stream);
  716.       }
  717.     default:
  718.       break;
  719.     }
  720.   }
  721.   rtp_byte_stream = new CRtpByteStream(fmt->media->media,
  722.        fmt, 
  723.        rtp_pt,
  724.        ondemand,
  725.        tps,
  726.        head,
  727.        tail,
  728.        rtp_seq_set, 
  729.        rtp_seq,
  730.        rtp_ts_set,
  731.        rtp_base_ts,
  732.        rtcp_received,
  733.        ntp_frac,
  734.        ntp_sec,
  735.        rtp_ts);
  736.   return (rtp_byte_stream);
  737. }