media_utils.cpp

网络MPEG4IP流媒体开发源代码

    sdp_decode_info_free(sdp_info);
    return (-1);
  }

  int err;
  if (sdp->control_string != NULL) {
    // An on demand file... Just use the URL...
    err = create_media_for_streaming_ondemand(psptr,
					      sdp->control_string,
					      errmsg,
					      errlen,
					      cc_vft);
    sdp_free_session_desc(sdp);
    sdp_decode_info_free(sdp_info);
    return (err);
  }
  sdp_decode_info_free(sdp_info);
  return (create_media_for_streaming_broadcast(psptr,
					       name, 
					       sdp,
					       errmsg,
					       errlen,
					       have_audio_driver,
					       cc_vft));
}

static int create_media_from_sdp_file(CPlayerSession *psptr, 
				      const char *name, 
				      char *errmsg,
				      uint32_t errlen,
				      int have_audio_driver,
				      control_callback_vft_t *cc_vft)
{
  sdp_decode_info_t *sdp_info;
  sdp_info = set_sdp_decode_from_filename(name);

  return (create_from_sdp(psptr, 
			  name, 
			  errmsg, 
			  errlen, 
			  sdp_info, 
			  have_audio_driver, 
			  cc_vft));
}

static int create_media_for_http (CPlayerSession *psptr,
				  const char *name,
				  char *errmsg,
				  uint32_t errlen,
				  control_callback_vft_t *cc_vft)
{
  http_client_t *http_client;

  int ret;
  http_resp_t *http_resp;
  http_resp = NULL;
  http_client = http_init_connection(name);

  if (http_client == NULL) {
    snprintf(errmsg, errlen, "Can't create http client");
    return -1;
  } 
  ret = http_get(http_client, NULL, &http_resp);
  if (ret > 0) {
    sdp_decode_info_t *sdp_info;

    int have_audio_driver = do_we_have_audio();
    sdp_info = set_sdp_decode_from_memory(http_resp->body);
    ret = create_from_sdp(psptr, 
			  name, 
			  errmsg, 
			  errlen, 
			  sdp_info, 
			  have_audio_driver,
			  cc_vft);
  } else {
    ret = -1;
  }
  http_resp_free(http_resp);
  http_free_connection(http_client);

  return (ret);
}
#ifndef _WIN32
static session_desc_t *find_sdp_for_program (const char *cm, 
					     const char *loc,
					     char *errmsg, 
					     uint32_t errlen,
					     uint64_t prog)
{
  char buffer[1024];
  http_client_t *http_client;
  http_resp_t *http_resp;
  sdp_decode_info_t *sdp_info;
  session_desc_t *sdp, *ptr, *sdp_ret;
  int translated;
  int ret, ix;

  snprintf(buffer, sizeof(buffer), "http://%s/%s", cm, loc);
    http_resp = NULL;
  http_client = http_init_connection(buffer);

  if (http_client == NULL) {
    snprintf(errmsg, errlen, "Cannot create http client with %s\n", 
	     cm);
    return NULL;
  }
  ret = http_get(http_client, NULL, &http_resp);
  
  sdp_ret = NULL;
  if (ret > 0) {
    sdp_info = set_sdp_decode_from_memory(http_resp->body);
    if ((sdp_decode(sdp_info, &sdp, &translated) == 0) &&
	(translated > 0)) {
      for (ix = 0; ix < translated && sdp_ret == NULL; ix++) {
	if (sdp->session_id == prog) {
	  sdp_ret = sdp;
	  sdp = sdp->next;
	  sdp_ret->next = NULL;
	} else {
	  ptr = sdp->next;
	  sdp->next = NULL;
	  sdp_free_session_desc(sdp);
	  sdp = ptr;
	}
      }
      sdp_decode_info_free(sdp_info);
      if (sdp != NULL) sdp_free_session_desc(sdp);
      
    } 
  }
  http_resp_free(http_resp);
  http_free_connection(http_client);
  return sdp_ret;
}

static int create_media_for_iptv (CPlayerSession *psptr,
				  const char *name,
				  char *errmsg,
				  uint32_t errlen,
				  int have_audio_driver,
				  control_callback_vft_t *cc_vft)
{
  char *slash, *cm;
  uint64_t prog;
  session_desc_t *sdp;

  name += strlen("iptv://");
  slash = strchr(name, '/');
  if (slash == NULL || slash == name) {
    snprintf(errmsg, errlen, "Invalid iptv content manager");
    return -1;
  }
  cm = (char *)malloc(slash - name + 1);
  memcpy(cm, name, slash - name);
  cm[slash - name] = '\0';
  slash++;
  if (sscanf(slash, "%llu", &prog) != 1) {
    snprintf(errmsg, errlen, "Invalid iptv program");
    return -1;
  }
  
  // check on-demand first
  sdp = find_sdp_for_program(cm, "iptvfiles/guide.sdf",
			     errmsg, errlen, prog);
  if (sdp == NULL) {
    sdp = find_sdp_for_program(cm, "servlet/OdPublish", 
			       errmsg, errlen, prog);
  }
  free(cm);

  if (sdp == NULL) {
    return -1;
  }
  int err;
  if (sdp->control_string != NULL) {
    // An on demand file... Just use the URL...
    err = create_media_for_streaming_ondemand(psptr,
					      sdp->control_string,
					      errmsg,
					      errlen,
					      cc_vft);
    sdp_free_session_desc(sdp);
    return (err);
  }
  return (create_media_for_streaming_broadcast(psptr,
					       name, 
					       sdp,
					       errmsg,
					       errlen,
					       have_audio_driver,
					       cc_vft));
}  
#endif

/*
 * parse_name_for_session - look at the name, determine what routine to 
 * call to set up the session.  This should be redone with plugins at
 * some point.
 */
#define ADV_SPACE(a) {while (isspace(*(a)) && (*(a) != '\0'))(a)++;}

int parse_name_for_session (CPlayerSession *psptr,
			    const char *name,
			    char *errmsg,
			    uint32_t errlen,
			    control_callback_vft_t *cc_vft)
{
  int err;
  ADV_SPACE(name);
  if (strncmp(name, "rtsp://", strlen("rtsp://")) == 0) {    
    err = create_media_for_streaming_ondemand(psptr, 
					      name, 
					      errmsg, 
					      errlen,
					      cc_vft);
    return (err);
  }
  if (strncmp(name, "http://", strlen("http://")) == 0) {
    err = create_media_for_http(psptr, name, errmsg, errlen, cc_vft);
    return (err);
  }    

  int have_audio_driver;

  have_audio_driver = do_we_have_audio();
#ifndef _WIN32
  if (strncmp(name, "iptv://", strlen("iptv://")) == 0) {
    err = create_media_for_iptv(psptr, 
				name, 
				errmsg, 
				errlen, 
				have_audio_driver, 
				cc_vft);
    return err;
  }
#endif
#ifndef _WIN32
  if (strncmp(name, "mpeg2t://", strlen("mpeg2t://")) == 0) {
    err = create_mpeg2t_session(psptr, name, NULL, errmsg, errlen, 
				have_audio_driver, cc_vft);
    return (err);
  }

  struct stat statbuf;
  if (stat(name, &statbuf) != 0) {
    snprintf(errmsg, errlen, "File \'%s\' not found", name);
    return (-1);
  }
  if (!S_ISREG(statbuf.st_mode)) {
    snprintf(errmsg, errlen, "File \'%s\' is not a file", name);
    return (-1);
  }
#else
  OFSTRUCT ReOpenBuff;
  if (OpenFile(name, &ReOpenBuff,OF_READ) == HFILE_ERROR) {
    snprintf(errmsg, errlen, "File %s not found", name);
    return (-1);
  }

#endif
  err = -1;

  const char *suffix = strrchr(name, '.');
  if (suffix == NULL) {
    snprintf(errmsg, errlen, "No useable suffix on file %s", name);
    return err;
  }


  if (strcasecmp(suffix, ".sdp") == 0) {
    err = create_media_from_sdp_file(psptr, 
				     name, 
				     errmsg, 
				     errlen, 
				     have_audio_driver,
				     cc_vft);
  } else if ((strcasecmp(suffix, ".mov") == 0) ||
	     ((config.get_config_value(CONFIG_USE_OLD_MP4_LIB) != 0) &&
	      (strcasecmp(suffix, ".mp4") == 0))){
    err = create_media_for_qtime_file(psptr, 
				      name, 
				      errmsg, 
				      errlen,
				      have_audio_driver);
  } else if (strcasecmp(suffix, ".mp4") == 0) {
    err = create_media_for_mp4_file(psptr, 
				    name, 
				    errmsg, 
				    errlen,
				    have_audio_driver,
				    cc_vft);
  } else if (strcasecmp(suffix, ".avi") == 0) {
    err = create_media_for_avi_file(psptr, 
				    name, 
				    errmsg, 
				    errlen, 
				    have_audio_driver,
				    cc_vft);
  } else if (strcasecmp(suffix, ".mpeg") == 0 ||
	     strcasecmp(suffix, ".mpg") == 0) {
    err = create_media_for_mpeg_file(psptr, name, errmsg, 
				     errlen, have_audio_driver, cc_vft);
  } else {
    // raw files
    if (have_audio_driver) {
      err = audio_codec_check_for_raw_file(psptr, name);
    }
    if (err < 0) {
      err = video_codec_check_for_raw_file(psptr, name);
    }
  }
  
  if (err >= 0) {
    const char *temp;
    temp = psptr->get_session_desc(0);
    if (temp == NULL) {
      psptr->set_session_desc(0, name);
    }
  }
  return (err);
}

int check_name_for_network (const char *name, 
			    int &isOnDemand, 
			    int &isRtpOverRtsp)
{
  sdp_decode_info_t *sdp_info;
  session_desc_t *sdp;
  int translated;
  http_resp_t *http_resp;
  int do_sdp = 0;

  http_resp = NULL;
  isOnDemand = 0;
  isRtpOverRtsp = 0;
  sdp_info = NULL;
  if (strncmp(name, "mpeg2t://", strlen("mpeg2t://")) == 0) {
    return 1;
  }
  if (strncmp(name, "iptv://", strlen("iptv://")) == 0) {
    // more later to handle the on demand/streaming case
    return 1;
  }
  if (strncmp(name, "rtsp://", strlen("rtsp://")) == 0) {
    isOnDemand = 1;
    isRtpOverRtsp = config.get_config_value(CONFIG_USE_RTP_OVER_RTSP);
    return 1;
  }
  // handle http, .sdp case
  if (strncmp(name, "http://", strlen("http://")) == 0) {
    http_client_t *http_client;
    int ret;
    http_client = http_init_connection(name);

    if (http_client == NULL) {
      return -1;
    } 
    ret = http_get(http_client, NULL, &http_resp);
    if (ret > 0) {
      sdp_decode_info_t *sdp_info;
      sdp_info = set_sdp_decode_from_memory(http_resp->body);
      do_sdp = 1;
      http_free_connection(http_client);
    } else return -1;
    do_sdp = 1;
  } else {
    const char *suffix = strrchr(name, '.');
    if (suffix == NULL) {
      return -1;
    }
    if (strcasecmp(suffix, ".sdp") == 0) {
      sdp_info = set_sdp_decode_from_filename(name);
      do_sdp = 1;
    } else 
      return 0;
  }
  if (do_sdp != 0) {
    if ((sdp_decode(sdp_info, &sdp, &translated) != 0) ||
	translated != 1){
      sdp_decode_info_free(sdp_info);
      return (-1);
    }
    if (sdp->control_string != NULL) {
      isOnDemand = 1;
      isRtpOverRtsp = config.get_config_value(CONFIG_USE_RTP_OVER_RTSP);
    }
    sdp_free_session_desc(sdp);
    if (http_resp != NULL)
      http_resp_free(http_resp);
    sdp_decode_info_free(sdp_info);
    return 1;
  }
  return 0;
}

/* end file media_utils.cpp */