Beispiel #1
0
CodecVector CHTSPData::GetTranscodingCodecs(void)
{
  htsmsg_t *msg;
  htsmsg_field_t *f;
  CodecVector v;
  CHTSResult result;

  msg = htsmsg_create_map();
  htsmsg_add_str(msg, "method", "getCodecs");

  ReadResult(msg, result);
  if (result.status != PVR_ERROR_NO_ERROR)
  {
    XBMC->Log(LOG_DEBUG, "%s - failed to getCodecs", __FUNCTION__);
    return v;
  }

  msg = htsmsg_get_list(result.message, "encoders");
  if(!msg)
  {
    XBMC->Log(LOG_DEBUG, "%s - failed to get encoders", __FUNCTION__);
    return v;
  }

  HTSMSG_FOREACH(f, msg) {
    if (f->hmf_type != HMF_STR)
      continue;

    CodecDescriptor codec = CodecDescriptor::GetCodecByName(f->hmf_str);
    if (codec.Codec().codec_type != XBMC_CODEC_TYPE_UNKNOWN)
      v.push_back(codec);
  }

  return v;
}
Beispiel #2
0
void CHTSPDemuxer::ParseSubscriptionStart ( htsmsg_t *m )
{
  vector<XbmcPvrStream>  streams;
  htsmsg_t               *l;
  htsmsg_field_t         *f;
  DemuxPacket            *pkt;

  /* Validate */
  if ((l = htsmsg_get_list(m, "streams")) == NULL)
  {
    Logger::Log(LogLevel::LEVEL_ERROR, "malformed subscriptionStart: 'streams' missing");
    return;
  }
  m_streamStat.clear();

  /* Process each */
  HTSMSG_FOREACH(f, l)
  {
    uint32_t      idx, u32;
    const char    *type;
    XbmcPvrStream stream;

    if (f->hmf_type != HMF_MAP)
      continue;
    if ((type = htsmsg_get_str(&f->hmf_msg, "type")) == NULL)
      continue;
    if (htsmsg_get_u32(&f->hmf_msg, "index", &idx))
      continue;

    /* Find stream */
    m_streamStat[idx] = 0;
    m_streams.GetStreamData(idx, &stream);
    Logger::Log(LogLevel::LEVEL_DEBUG, "demux subscription start");
    
    CodecDescriptor codecDescriptor = CodecDescriptor::GetCodecByName(type);
    xbmc_codec_t codec = codecDescriptor.Codec();
    
    if (codec.codec_type != XBMC_CODEC_TYPE_UNKNOWN)
    {
      stream.iCodecType  = codec.codec_type;
      stream.iCodecId    = codec.codec_id;
      stream.iPhysicalId = idx;

      /* Subtitle ID */
      if ((stream.iCodecType == XBMC_CODEC_TYPE_SUBTITLE) &&
          !strcmp("DVBSUB", type))
      {
        uint32_t composition_id = 0, ancillary_id = 0;
        htsmsg_get_u32(&f->hmf_msg, "composition_id", &composition_id);
        htsmsg_get_u32(&f->hmf_msg, "ancillary_id"  , &ancillary_id);
        stream.iIdentifier = (composition_id & 0xffff)
                           | ((ancillary_id & 0xffff) << 16);
      }

      /* Language */
      if (stream.iCodecType == XBMC_CODEC_TYPE_SUBTITLE ||
          stream.iCodecType == XBMC_CODEC_TYPE_AUDIO)
      {
        const char *language;
        
        if ((language = htsmsg_get_str(&f->hmf_msg, "language")) != NULL)
          strncpy(stream.strLanguage, language, sizeof(stream.strLanguage) - 1);
      }

      /* Audio data */
      if (stream.iCodecType == XBMC_CODEC_TYPE_AUDIO)
      {
        stream.iChannels
          = htsmsg_get_u32_or_default(&f->hmf_msg, "channels", 2);
        stream.iSampleRate
          = htsmsg_get_u32_or_default(&f->hmf_msg, "rate", 48000);
      }

      /* Video */
      if (stream.iCodecType == XBMC_CODEC_TYPE_VIDEO)
      {
        stream.iWidth   = htsmsg_get_u32_or_default(&f->hmf_msg, "width", 0);
        stream.iHeight  = htsmsg_get_u32_or_default(&f->hmf_msg, "height", 0);
        
        /* Ignore this message if the stream details haven't been determined 
           yet, a new message will be sent once they have. This is fixed in 
           some versions of tvheadend and is here for backward compatibility. */
        if (stream.iWidth == 0 || stream.iHeight == 0)
        {
          Logger::Log(LogLevel::LEVEL_DEBUG, "Ignoring subscriptionStart, stream details missing");
          return;
        }
        
        /* Setting aspect ratio to zero will cause XBMC to handle changes in it */
        stream.fAspect = 0.0f;
        
        if ((u32 = htsmsg_get_u32_or_default(&f->hmf_msg, "duration", 0)) > 0)
        {
          stream.iFPSScale = u32;
          stream.iFPSRate  = DVD_TIME_BASE;
        }
      }
        
      streams.push_back(stream);
      Logger::Log(LogLevel::LEVEL_DEBUG, "  id: %d, type %s, codec: %u", idx, type, stream.iCodecId);
    }
  }
Beispiel #3
0
ADDON_STATUS ADDON_SetSetting(const char *settingName, const void *settingValue)
{
  string str = settingName;
  if (str == "host")
  {
    string tmp_sHostname;
    XBMC->Log(LOG_INFO, "%s - Changed Setting 'host' from %s to %s", __FUNCTION__, g_strHostname.c_str(), (const char*) settingValue);
    tmp_sHostname = g_strHostname;
    g_strHostname = (const char*) settingValue;
    if (tmp_sHostname != g_strHostname)
      return ADDON_STATUS_NEED_RESTART;
  }
  else if (str == "user")
  {
    string tmp_sUsername = g_strUsername;
    g_strUsername = (const char*) settingValue;
    if (tmp_sUsername != g_strUsername)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'user'", __FUNCTION__);
      return ADDON_STATUS_NEED_RESTART;
    }
  }
  else if (str == "pass")
  {
    string tmp_sPassword = g_strPassword;
    g_strPassword = (const char*) settingValue;
    if (tmp_sPassword != g_strPassword)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'pass'", __FUNCTION__);
      return ADDON_STATUS_NEED_RESTART;
    }
  }
  else if (str == "htsp_port")
  {
    if (g_iPortHTSP != *(int*) settingValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'htsp_port' from %u to %u", __FUNCTION__, g_iPortHTSP, *(int*) settingValue);
      g_iPortHTSP = *(int*) settingValue;
      return ADDON_STATUS_NEED_RESTART;
    }
  }
  else if (str == "http_port")
  {
    if (g_iPortHTTP != *(int*) settingValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'port' from %u to %u", __FUNCTION__, g_iPortHTTP, *(int*) settingValue);
      g_iPortHTTP = *(int*) settingValue;
      return ADDON_STATUS_NEED_RESTART;
    }
  }
  else if (str == "connect_timeout")
  {
    int iNewValue = *(int*) settingValue + 1;
    if (g_iConnectTimeout != iNewValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'connect_timeout' from %u to %u", __FUNCTION__, g_iConnectTimeout, iNewValue);
      g_iConnectTimeout = iNewValue;
      return ADDON_STATUS_OK;
    }
  }
  else if (str == "response_timeout")
  {
    int iNewValue = *(int*) settingValue + 1;
    if (g_iResponseTimeout != iNewValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'response_timeout' from %u to %u", __FUNCTION__, g_iResponseTimeout, iNewValue);
      g_iResponseTimeout = iNewValue;
      return ADDON_STATUS_OK;
    }
  }
  else if (str == "transcode")
  {
    int bNewValue = *(bool*) settingValue;
    XBMC->Log(LOG_INFO, "%s - Changed Setting 'transcode' from %u to %u", __FUNCTION__, g_bTranscode, bNewValue);
    g_bTranscode = (bNewValue == 1);
  }
  else if (str == "resolution")
  {
    int iNewValue = *(int*) settingValue + 1;
    if (g_iResolution != iNewValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'resolution' from %u to %u", __FUNCTION__, g_iResolution, iNewValue);
      g_iResolution = iNewValue;
      return ADDON_STATUS_OK;
    }
  }
  else if (str == "video_codec_name")
  {
    string tmp_strCodecname = g_videoCodec.Name();
    if (tmp_strCodecname != (const char*) settingValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'video_codec' from %s to %s", __FUNCTION__, tmp_strCodecname.c_str(), (const char*) settingValue);
      g_videoCodec = CodecDescriptor::GetCodecByName((const char*) settingValue);
      return ADDON_STATUS_OK;
    }
  }
  else if (str == "audio_codec_name")
  {
    string tmp_strCodecname = g_audioCodec.Name();
    if (tmp_strCodecname != (const char*) settingValue)
    {
      XBMC->Log(LOG_INFO, "%s - Changed Setting 'audio_codec' from %s to %s", __FUNCTION__, tmp_strCodecname.c_str(), (const char*) settingValue);
      g_audioCodec = CodecDescriptor::GetCodecByName((const char*) settingValue);
      return ADDON_STATUS_OK;
    }
  }

  return ADDON_STATUS_OK;
}
Beispiel #4
0
void CHTSPDemux::ParseSubscriptionStart(htsmsg_t *m)
{
  vector<PVR_STREAM_PROPERTIES::PVR_STREAM> newStreams;

  htsmsg_t       *streams;
  htsmsg_field_t *f;
  uint32_t        subs;

  if(htsmsg_get_u32(m, "subscriptionId", &subs))
  {
    XBMC->Log(LOG_ERROR, "%s - invalid subscription id", __FUNCTION__);
    return;
  }
  m_subs = subs;

  if((streams = htsmsg_get_list(m, "streams")) == NULL)
  {
    XBMC->Log(LOG_ERROR, "%s - malformed message", __FUNCTION__);
    return;
  }

  HTSMSG_FOREACH(f, streams)
  {
    uint32_t    index;
    const char* type;
    htsmsg_t*   sub;

    if (newStreams.size() >= PVR_STREAM_MAX_STREAMS)
    {
      XBMC->Log(LOG_ERROR, "%s - max amount of streams reached", __FUNCTION__);
      break;
    }

    if (f->hmf_type != HMF_MAP)
      continue;

    sub = &f->hmf_msg;

    if ((type = htsmsg_get_str(sub, "type")) == NULL)
      continue;

    if (htsmsg_get_u32(sub, "index", &index))
      continue;

    bool bValidStream(true);
    PVR_STREAM_PROPERTIES::PVR_STREAM newStream;
    m_streams.GetStreamData(index, &newStream);

    CodecDescriptor codecId = CodecDescriptor::GetCodecByName(type);
    if (codecId.Codec().codec_type != XBMC_CODEC_TYPE_UNKNOWN)
    {
      newStream.iCodecType = codecId.Codec().codec_type;
      newStream.iCodecId   = codecId.Codec().codec_id;

      if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_SUBTITLE)
      {
        uint32_t composition_id = 0, ancillary_id = 0;
        htsmsg_get_u32(sub, "composition_id", &composition_id);
        htsmsg_get_u32(sub, "ancillary_id"  , &ancillary_id);
        newStream.iIdentifier = (composition_id & 0xffff) | ((ancillary_id & 0xffff) << 16);
        HTSPSetDemuxStreamInfoLanguage(newStream, sub);
      }
    }
    else
    {
      bValidStream = false;
    }

    if (bValidStream)
    {
      XBMC->Log(LOG_DEBUG, "%s - id: %d, type: %s, codec: %u", __FUNCTION__, index, codecId.Name().c_str(), codecId.Codec().codec_id);

      newStream.iPhysicalId  = index;
      if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_AUDIO)
      {
        HTSPSetDemuxStreamInfoAudio(newStream, sub);
        HTSPSetDemuxStreamInfoLanguage(newStream, sub);
      }
      else if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_VIDEO)
        HTSPSetDemuxStreamInfoVideo(newStream, sub);

      newStreams.push_back(newStream);
    }
    else
    {
      XBMC->Log(LOG_DEBUG, "%s - id: %d, type: %s, ignored", __FUNCTION__, index, type);
    }
  }
Beispiel #5
0
void cVNSIDemux::StreamChange(cResponsePacket *resp)
{
  std::vector<XbmcPvrStream> newStreams;

  while (!resp->end())
  {
    uint32_t    pid = resp->extract_U32();
    const char* type  = resp->extract_String();

    XbmcPvrStream newStream;
    m_streams.GetStreamData(pid, &newStream);

    CodecDescriptor codecId = CodecDescriptor::GetCodecByName(type);
    if (codecId.Codec().codec_type != XBMC_CODEC_TYPE_UNKNOWN)
    {
      newStream.iPhysicalId     = pid;
      newStream.iCodecType      = codecId.Codec().codec_type;
      newStream.iCodecId        = codecId.Codec().codec_id;
    }
    else
    {
      return;
    }

    if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_AUDIO)
    {
      const char *language = resp->extract_String();

      newStream.iChannels       = resp->extract_U32();
      newStream.iSampleRate     = resp->extract_U32();
      newStream.iBlockAlign     = resp->extract_U32();
      newStream.iBitRate        = resp->extract_U32();
      newStream.iBitsPerSample  = resp->extract_U32();
      newStream.strLanguage[0]  = language[0];
      newStream.strLanguage[1]  = language[1];
      newStream.strLanguage[2]  = language[2];
      newStream.strLanguage[3]  = 0;
      newStream.iIdentifier     = -1;

      newStreams.push_back(newStream);
    }
    else if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_VIDEO)
    {
      newStream.iFPSScale       = resp->extract_U32();
      newStream.iFPSRate        = resp->extract_U32();
      newStream.iHeight         = resp->extract_U32();
      newStream.iWidth          = resp->extract_U32();
      newStream.fAspect         = (float)resp->extract_Double();
      newStream.strLanguage[0]  = 0;
      newStream.strLanguage[1]  = 0;
      newStream.strLanguage[2]  = 0;
      newStream.strLanguage[3]  = 0;
      newStream.iIdentifier     = -1;

      newStreams.push_back(newStream);
    }
    else if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_SUBTITLE)
    {
      const char *language    = resp->extract_String();
      uint32_t composition_id = resp->extract_U32();
      uint32_t ancillary_id   = resp->extract_U32();
      newStream.strLanguage[0]  = language[0];
      newStream.strLanguage[1]  = language[1];
      newStream.strLanguage[2]  = language[2];
      newStream.strLanguage[3]  = 0;
      newStream.iIdentifier     = (composition_id & 0xffff) | ((ancillary_id & 0xffff) << 16);

      newStreams.push_back(newStream);

      delete[] language;
    }
    else if (codecId.Codec().codec_type == XBMC_CODEC_TYPE_RDS)
    {
      const char *language     = resp->extract_String();
      uint32_t rel_channel_pid = resp->extract_U32();
      newStream.strLanguage[0]  = language[0];
      newStream.strLanguage[1]  = language[1];
      newStream.strLanguage[2]  = language[2];
      newStream.strLanguage[3]  = 0;
      newStream.iIdentifier     = -1;

      newStreams.push_back(newStream);

      delete[] language;
    }
    else
    {
      m_streams.Clear();
      delete[] type;
      return;
    }

    delete[] type;
  }

  m_streams.UpdateStreams(newStreams);
}