예제 #1
0
static int
play_with_context(const char *uri, htsmsg_t *meta)
{
  const char *parentid, *id;
  upnp_service_t *us;

  parentid =
    htsmsg_get_str_multi(meta,
			 "DIDL-Lite",
			 "item",
			 "parentID",
			 NULL);

  if(parentid == NULL)
    return 1;

  id =
    htsmsg_get_str_multi(meta,
			 "DIDL-Lite",
			 "item",
			 "id",
			 NULL);

  if(id == NULL)
    return 1;

  UPNP_TRACE("Playing %s (id: %s, parent: %s)", uri, id, parentid);

  hts_mutex_lock(&upnp_lock);

  us = upnp_service_guess(uri);

  if(us != NULL) {
    UPNP_TRACE("Using controlpoint %s", us->us_control_url);

    prop_t *model = prop_create_root(NULL);
    prop_t *nodes = prop_create(model, "nodes");
    prop_t *t = NULL;

    if(upnp_browse_children(us->us_control_url, parentid, nodes, id, &t) 
       || t == NULL) {

      prop_destroy(model);

    } else {
      playqueue_load_with_source(t, model, PQ_PAUSED);
      hts_mutex_unlock(&upnp_lock);
      return 0;
    }
  }

  hts_mutex_unlock(&upnp_lock);
  return 1;
}
예제 #2
0
static void
screenshot_process(void *task)
{
  pixmap_t *pm = task;

  if(pm == NULL) {
    screenshot_response(NULL, "Screenshot not supported on this platform");
    return;
  }

  TRACE(TRACE_DEBUG, "Screenshot", "Processing image %d x %d",
        pm->pm_width, pm->pm_height);

  int codecid = AV_CODEC_ID_PNG;
  if(screenshot_connection)
    codecid = AV_CODEC_ID_MJPEG;

  buf_t *b = screenshot_compress(pm, codecid);
  pixmap_release(pm);
  if(b == NULL) {
    screenshot_response(NULL, "Unable to compress image");
    return;
  }

  if(!screenshot_connection) {
    char path[512];
    char errbuf[512];
    snprintf(path, sizeof(path), "%s/screenshot.png",
             gconf.cache_path);
    fa_handle_t *fa = fa_open_ex(path, errbuf, sizeof(errbuf),
                                 FA_WRITE, NULL);
    if(fa == NULL) {
      TRACE(TRACE_ERROR, "SCREENSHOT", "Unable to open %s -- %s",
            path, errbuf);
      buf_release(b);
      return;
    }
    fa_write(fa, buf_data(b), buf_len(b));
    fa_close(fa);
    TRACE(TRACE_INFO, "SCREENSHOT", "Written to %s", path);
    buf_release(b);
    return;
  }

  buf_t *result = NULL;
  htsbuf_queue_t hq;
  htsbuf_queue_init(&hq, 0);

  htsbuf_append(&hq, "image=", 6);
  htsbuf_append_and_escape_url_len(&hq, buf_cstr(b), buf_len(b));

  char errbuf[256];

  int ret = http_req("https://api.imgur.com/3/upload",
                     HTTP_FLAGS(FA_CONTENT_ON_ERROR),
                     HTTP_REQUEST_HEADER("Authorization",
                                         "Client-ID 7c79b311d4797ed"),
                     HTTP_RESULT_PTR(&result),
                     HTTP_POSTDATA(&hq, "application/x-www-form-urlencoded"),
                     HTTP_ERRBUF(errbuf, sizeof(errbuf)),
                     NULL);


  if(ret) {
    screenshot_response(NULL, errbuf);
  } else {

    htsmsg_t *response = htsmsg_json_deserialize(buf_cstr(result));
    if(response == NULL) {
      screenshot_response(NULL, "Unable to parse imgur response");
    } else {

      if(htsmsg_get_u32_or_default(response, "success", 0)) {
        const char *url = htsmsg_get_str_multi(response, "data", "link", NULL);
        screenshot_response(url, "No link in imgur response");
      } else {
        const char *msg = htsmsg_get_str_multi(response, "data", "error", NULL);
        if(msg == NULL) {
          screenshot_response(NULL, "Unkown imgur error");
        } else {
          snprintf(errbuf, sizeof(errbuf), "Imgur error: %s", msg);
          screenshot_response(NULL, errbuf);
        }
      }
      htsmsg_release(response);
    }
    buf_release(result);
  }
  buf_release(b);
}