static gboolean parse_json (GDataParsable *parsable, JsonReader *reader, gpointer user_data, GError **error) { gboolean success = TRUE; gchar *next_uri = NULL; /* JSON format: https://developers.google.com/drive/v2/reference/files/list */ if (gdata_parser_string_from_json_member (reader, "nextLink", P_DEFAULT, &next_uri, &success, error) == TRUE) { if (success && next_uri != NULL && next_uri[0] != '\0') { GDataLink *_link; _link = gdata_link_new (next_uri, "http://www.iana.org/assignments/relation/next"); _gdata_feed_add_link (GDATA_FEED (parsable), _link); g_object_unref (_link); } g_free (next_uri); return success; } else if (g_strcmp0 (json_reader_get_member_name (reader), "items") == 0) { guint i, elements; if (json_reader_is_array (reader) == FALSE) { g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the parameter is an error message */ _("Error parsing JSON: %s"), "JSON node ‘items’ is not an array."); return FALSE; } /* Loop through the elements array. */ for (i = 0, elements = (guint) json_reader_count_elements (reader); success && i < elements; i++) { GDataEntry *entry = NULL; GError *child_error = NULL; GType entry_type = G_TYPE_INVALID; gchar *kind = NULL; gchar *mime_type = NULL; json_reader_read_element (reader, i); if (json_reader_is_object (reader) == FALSE) { g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_PROTOCOL_ERROR, /* Translators: the parameter is an error message */ _("Error parsing JSON: %s"), "JSON node inside ‘items’ is not an object"); success = FALSE; goto continuation; } get_kind_and_mime_type (reader, &kind, &mime_type, &child_error); if (child_error != NULL) { g_propagate_error (error, child_error); success = FALSE; goto continuation; } if (g_strcmp0 (kind, "drive#file") == 0) { entry_type = gdata_documents_utils_get_type_from_content_type (mime_type); } else { g_warning ("%s files are not handled yet", kind); } if (entry_type == G_TYPE_INVALID) goto continuation; entry = GDATA_ENTRY (_gdata_parsable_new_from_json_node (entry_type, reader, NULL, error)); /* Call the progress callback in the main thread */ _gdata_feed_call_progress_callback (GDATA_FEED (parsable), user_data, entry); _gdata_feed_add_entry (GDATA_FEED (parsable), entry); continuation: g_clear_object (&entry); g_free (kind); g_free (mime_type); json_reader_end_element (reader); } return success; } return GDATA_PARSABLE_CLASS (gdata_documents_feed_parent_class)->parse_json (parsable, reader, user_data, error); }
/* Save key/values on the table in the stack if the value is an * object or an array, it calls recursively the function again. * * @param L, pointer to the L with nil on top of it; * @param reader, pointed to the first element of main object; * * returns: the table in the stack with all json values */ static void build_table_from_json_reader (lua_State *L, JsonReader *reader) { const GError *err = json_reader_get_error (reader); if (err != NULL) { GRL_WARNING ("Error when building json: %s", err->message); return; } if (lua_isnil (L, -1)) { /* In the first execution of this recursive call, the main json object * does not have a member name. The nil is in the top of the stack and * it shall be converted to the table with json content */ lua_pop (L, 1); } else if (lua_istable (L, -1)) { const gchar *member_name = json_reader_get_member_name (reader); if (member_name) lua_pushstring (L, member_name); } else if (!lua_isnumber (L, -1)) { GRL_DEBUG ("getting value to either table or array"); return; } if (json_reader_is_object (reader)) { guint index_member = 0; guint num_members = json_reader_count_members (reader); lua_createtable (L, num_members, 0); for (index_member = 0; index_member < num_members; index_member++) { json_reader_read_element (reader, index_member); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_array (reader)) { guint index_element = 0; guint num_elements = json_reader_count_elements (reader); lua_createtable (L, num_elements, 0); for (index_element = 0; index_element < num_elements; index_element++) { json_reader_read_element (reader, index_element); lua_pushinteger (L, index_element + 1); build_table_from_json_reader (L, reader); json_reader_end_element (reader); } } else if (json_reader_is_value (reader)) { if (json_reader_get_null_value (reader)) { lua_pushnil (L); } else { /* value of the element */ JsonNode *value = json_reader_get_value (reader); switch (json_node_get_value_type (value)) { case G_TYPE_STRING: lua_pushstring (L, json_reader_get_string_value (reader)); break; case G_TYPE_INT64: lua_pushinteger (L, json_reader_get_int_value (reader)); break; case G_TYPE_DOUBLE: lua_pushnumber (L, json_reader_get_double_value (reader)); break; case G_TYPE_BOOLEAN: lua_pushnumber (L, json_reader_get_boolean_value (reader)); break; default: GRL_DEBUG ("'%d' (json-node-type) is not being handled", (gint) json_node_get_value_type (value)); lua_pushnil (L); } } } if (lua_gettop (L) > 3) { /* save this key/value on previous table */ lua_settable (L, -3); } }
GList *dt_noiseprofile_get_matching(const dt_image_t *cimg) { JsonParser *parser = darktable.noiseprofile_parser; JsonReader *reader = NULL; GList *result = NULL; if(!parser) goto end; dt_print(DT_DEBUG_CONTROL, "[noiseprofile] looking for maker `%s', model `%s'\n", cimg->camera_maker, cimg->camera_model); JsonNode *root = json_parser_get_root(parser); reader = json_reader_new(root); json_reader_read_member(reader, "noiseprofiles"); // go through all makers const int n_makers = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d makers\n", n_makers); for(int i = 0; i < n_makers; i++) { json_reader_read_element(reader, i); json_reader_read_member(reader, "maker"); if(g_strstr_len(cimg->camera_maker, -1, json_reader_get_string_value(reader))) { dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found `%s' as `%s'\n", cimg->camera_maker, json_reader_get_string_value(reader)); // go through all models and check those json_reader_end_member(reader); json_reader_read_member(reader, "models"); const int n_models = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d models\n", n_models); for(int j = 0; j < n_models; j++) { json_reader_read_element(reader, j); json_reader_read_member(reader, "model"); if(!g_strcmp0(cimg->camera_model, json_reader_get_string_value(reader))) { dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %s\n", cimg->camera_model); // we got a match, return at most bufsize elements json_reader_end_member(reader); json_reader_read_member(reader, "profiles"); const int n_profiles = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d profiles\n", n_profiles); for(int k = 0; k < n_profiles; k++) { dt_noiseprofile_t tmp_profile = { 0 }; json_reader_read_element(reader, k); gchar** member_names = json_reader_list_members(reader); // do we want to skip this entry? if(is_member(member_names, "skip")) { json_reader_read_member(reader, "skip"); gboolean skip = json_reader_get_boolean_value(reader); json_reader_end_member(reader); if(skip) { json_reader_end_element(reader); g_strfreev(member_names); continue; } } // maker tmp_profile.maker = g_strdup(cimg->camera_maker); // model tmp_profile.model = g_strdup(cimg->camera_model); // name json_reader_read_member(reader, "name"); tmp_profile.name = g_strdup(json_reader_get_string_value(reader)); json_reader_end_member(reader); // iso json_reader_read_member(reader, "iso"); tmp_profile.iso = json_reader_get_double_value(reader); json_reader_end_member(reader); // a json_reader_read_member(reader, "a"); for(int a = 0; a < 3; a++) { json_reader_read_element(reader, a); tmp_profile.a[a] = json_reader_get_double_value(reader); json_reader_end_element(reader); } json_reader_end_member(reader); // b json_reader_read_member(reader, "b"); for(int b = 0; b < 3; b++) { json_reader_read_element(reader, b); tmp_profile.b[b] = json_reader_get_double_value(reader); json_reader_end_element(reader); } json_reader_end_member(reader); json_reader_end_element(reader); // everything worked out, add tmp_profile to result dt_noiseprofile_t *new_profile = (dt_noiseprofile_t *)malloc(sizeof(dt_noiseprofile_t)); *new_profile = tmp_profile; result = g_list_append(result, new_profile); g_strfreev(member_names); } // profiles goto end; } json_reader_end_member(reader); json_reader_end_element(reader); } // models } json_reader_end_member(reader); json_reader_end_element(reader); } // makers json_reader_end_member(reader); end: if(reader) g_object_unref(reader); if(result) result = g_list_sort(result, _sort_by_iso); return result; }
static gboolean dt_noiseprofile_verify(JsonParser *parser) { JsonReader *reader = NULL; gboolean valid = TRUE; dt_print(DT_DEBUG_CONTROL, "[noiseprofile] verifying noiseprofile file\n"); JsonNode *root = json_parser_get_root(parser); if(!root) _ERROR("can't get the root node"); reader = json_reader_new(root); if(!json_reader_read_member(reader, "version")) _ERROR("can't find file version."); // check the file version const int version = json_reader_get_int_value(reader); json_reader_end_member(reader); if(version != DT_NOISE_PROFILE_VERSION) _ERROR("file version is not what this code understands"); if(!json_reader_read_member(reader, "noiseprofiles")) _ERROR("can't find `noiseprofiles' entry."); if(!json_reader_is_array(reader)) _ERROR("`noiseprofiles' is supposed to be an array"); // go through all makers const int n_makers = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d makers\n", n_makers); for(int i = 0; i < n_makers; i++) { if(!json_reader_read_element(reader, i)) _ERROR("can't access maker at position %d / %d", i+1, n_makers); if(!json_reader_read_member(reader, "maker")) _ERROR("missing `maker`"); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found maker `%s'\n", json_reader_get_string_value(reader)); // go through all models and check those json_reader_end_member(reader); if(!json_reader_read_member(reader, "models")) _ERROR("missing `models`"); const int n_models = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d models\n", n_models); for(int j = 0; j < n_models; j++) { if(!json_reader_read_element(reader, j)) _ERROR("can't access model at position %d / %d", j+1, n_models); if(!json_reader_read_member(reader, "model")) _ERROR("missing `model`"); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %s\n", json_reader_get_string_value(reader)); json_reader_end_member(reader); if(!json_reader_read_member(reader, "profiles")) _ERROR("missing `profiles`"); const int n_profiles = json_reader_count_elements(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] found %d profiles\n", n_profiles); for(int k = 0; k < n_profiles; k++) { if(!json_reader_read_element(reader, k)) _ERROR("can't access profile at position %d / %d", k+1, n_profiles); gchar** member_names = json_reader_list_members(reader); // name if(!is_member(member_names, "name")) { g_strfreev(member_names); _ERROR("missing `name`"); } // iso if(!is_member(member_names, "iso")) { g_strfreev(member_names); _ERROR("missing `iso`"); } // a if(!is_member(member_names, "a")) { g_strfreev(member_names); _ERROR("missing `a`"); } json_reader_read_member(reader, "a"); if(json_reader_count_elements(reader) != 3) { g_strfreev(member_names); _ERROR("`a` with size != 3"); } json_reader_end_member(reader); // b if(!is_member(member_names, "b")) { g_strfreev(member_names); _ERROR("missing `b`"); } json_reader_read_member(reader, "b"); if(json_reader_count_elements(reader) != 3) { g_strfreev(member_names); _ERROR("`b` with size != 3"); } json_reader_end_member(reader); json_reader_end_element(reader); g_strfreev(member_names); } // profiles json_reader_end_member(reader); json_reader_end_element(reader); } // models json_reader_end_member(reader); json_reader_end_element(reader); } // makers json_reader_end_member(reader); dt_print(DT_DEBUG_CONTROL, "[noiseprofile] verifying noiseprofile completed\n"); end: if(reader) g_object_unref(reader); return valid; }
/* The error format used by the Google Tasks API doesn’t seem to be documented * anywhere, which is a little frustrating. Here’s an example of it: * { * "error": { * "errors": [ * { * "domain": "usageLimits", * "reason": "dailyLimitExceededUnreg", * "message": "Daily Limit for Unauthenticated Use Exceeded.", * "extendedHelp": "https://code.google.com/apis/console" * } * ], * "code": 403, * "message": "Daily Limit for Unauthenticated Use Exceeded." * } * } * or: * { * "error": { * "errors": [ * { * "domain": "global", * "reason": "authError", * "message": "Invalid Credentials", * "locationType": "header", * "location": "Authorization" * } * ], * "code": 401, * "message": "Invalid Credentials" * } * } */ static void parse_error_response (GDataService *self, GDataOperationType operation_type, guint status, const gchar *reason_phrase, const gchar *response_body, gint length, GError **error) { JsonParser *parser = NULL; /* owned */ JsonReader *reader = NULL; /* owned */ gint i; GError *child_error = NULL; if (response_body == NULL) { goto parent; } if (length == -1) { length = strlen (response_body); } parser = json_parser_new (); if (!json_parser_load_from_data (parser, response_body, length, &child_error)) { goto parent; } reader = json_reader_new (json_parser_get_root (parser)); /* Check that the outermost node is an object. */ if (!json_reader_is_object (reader)) { goto parent; } /* Grab the ‘error’ member, then its ‘errors’ member. */ if (!json_reader_read_member (reader, "error") || !json_reader_is_object (reader) || !json_reader_read_member (reader, "errors") || !json_reader_is_array (reader)) { goto parent; } /* Parse each of the errors. Return the first one, and print out any * others. */ for (i = 0; i < json_reader_count_elements (reader); i++) { const gchar *domain, *reason, *message, *extended_help; const gchar *location_type, *location; /* Parse the error. */ if (!json_reader_read_element (reader, i) || !json_reader_is_object (reader)) { goto parent; } json_reader_read_member (reader, "domain"); domain = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "reason"); reason = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "message"); message = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "extendedHelp"); extended_help = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "locationType"); location_type = json_reader_get_string_value (reader); json_reader_end_member (reader); json_reader_read_member (reader, "location"); location = json_reader_get_string_value (reader); json_reader_end_member (reader); /* End the error element. */ json_reader_end_element (reader); /* Create an error message, but only for the first error */ if (error == NULL || *error == NULL) { if (g_strcmp0 (domain, "usageLimits") == 0 && g_strcmp0 (reason, "dailyLimitExceededUnreg") == 0) { /* Daily Limit for Unauthenticated Use * Exceeded. */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_API_QUOTA_EXCEEDED, _("You have made too many API " "calls recently. Please wait a " "few minutes and try again.")); } else if (g_strcmp0 (domain, "global") == 0 && (g_strcmp0 (reason, "authError") == 0 || g_strcmp0 (reason, "required") == 0)) { /* Authentication problem */ g_set_error (error, GDATA_SERVICE_ERROR, GDATA_SERVICE_ERROR_AUTHENTICATION_REQUIRED, _("You must be authenticated to " "do this.")); } else { /* Unknown or validation (protocol) error. Fall * back to working off the HTTP status code. */ g_warning ("Unknown error code ‘%s’ in domain " "‘%s’ received with location type " "‘%s’, location ‘%s’, extended help " "‘%s’ and message ‘%s’.", reason, domain, location_type, location, extended_help, message); goto parent; } } else { /* For all errors after the first, log the error in the * terminal. */ g_debug ("Error message received in response: domain " "‘%s’, reason ‘%s’, extended help ‘%s’, " "message ‘%s’, location type ‘%s’, location " "‘%s’.", domain, reason, extended_help, message, location_type, location); } } /* End the ‘errors’ and ‘error’ members. */ json_reader_end_element (reader); json_reader_end_element (reader); g_clear_object (&reader); g_clear_object (&parser); /* Ensure we’ve actually set an error message. */ g_assert (error == NULL || *error != NULL); return; parent: g_clear_object (&reader); g_clear_object (&parser); /* Chain up to the parent class */ GDATA_SERVICE_CLASS (gdata_tasks_service_parent_class)->parse_error_response (self, operation_type, status, reason_phrase, response_body, length, error); }
static void get_language_names(GList *languages) { #ifdef HAVE_ISO_CODES JsonReader *reader = NULL; JsonParser *parser = NULL; GError *error = NULL; #if defined(_WIN32) && !defined(MSYS2_INSTALL) // TODO: add osx? char datadir[PATH_MAX] = { 0 }; dt_loc_get_datadir(datadir, sizeof(datadir)); char *filename = g_build_filename(datadir, "..", "iso-codes", "json", "iso_639-2.json", NULL); #else char *filename = g_build_filename(ISO_CODES_LOCATION, "iso_639-2.json", NULL); #endif if(!g_file_test(filename, G_FILE_TEST_EXISTS)) { fprintf(stderr, "[l10n] error: can't open iso-codes file `%s'\n" " there won't be nicely translated language names in the preferences.\n", filename); goto end; } #if defined(_WIN32) && !defined(MSYS2_INSTALL) // TODO: add osx? // on windows we are shipping the translations of iso-codes along ours char *localedir = g_build_filename(datadir, "..", "locale", NULL); bindtextdomain("iso_639", localedir); g_free(localedir); #else bindtextdomain("iso_639", ISO_CODES_LOCALEDIR); #endif bind_textdomain_codeset("iso_639", "UTF-8"); parser = json_parser_new(); if(!json_parser_load_from_file(parser, filename, &error)) { fprintf(stderr, "[l10n] error: parsing json from `%s' failed\n%s\n", filename, error->message); goto end; } // go over the json JsonNode *root = json_parser_get_root(parser); if(!root) { fprintf(stderr, "[l10n] error: can't get root node of `%s'\n", filename); goto end; } reader = json_reader_new(root); if(!json_reader_read_member(reader, "639-2")) { fprintf(stderr, "[l10n] error: unexpected layout of `%s'\n", filename); goto end; } if(!json_reader_is_array(reader)) { fprintf(stderr, "[l10n] error: unexpected layout of `%s'\n", filename); goto end; } int n_elements = json_reader_count_elements(reader); for(int i = 0; i < n_elements; i++) { json_reader_read_element(reader, i); if(!json_reader_is_object(reader)) { fprintf(stderr, "[l10n] error: unexpected layout of `%s' (element %d)\n", filename, i); goto end; } const char *alpha_2 = NULL, *alpha_3 = NULL, *name = NULL; if(json_reader_read_member(reader, "alpha_2")) alpha_2 = json_reader_get_string_value(reader); json_reader_end_member(reader); // alpha_2 if(json_reader_read_member(reader, "alpha_3")) alpha_3 = json_reader_get_string_value(reader); json_reader_end_member(reader); // alpha_3 if(json_reader_read_member(reader, "name")) name = json_reader_get_string_value(reader); json_reader_end_member(reader); // name if(name && (alpha_2 || alpha_3)) { // check if alpha_2 or alpha_3 is in our translations for(GList *iter = languages; iter; iter = g_list_next(iter)) { dt_l10n_language_t *language = (dt_l10n_language_t *)iter->data; if(!g_strcmp0(language->base_code, alpha_2) || !g_strcmp0(language->base_code, alpha_3)) { // code taken in parts from GIMP's gimplanguagestore-parser.c g_setenv("LANGUAGE", language->code, TRUE); setlocale (LC_ALL, language->code); char *localized_name = g_strdup(dgettext("iso_639", name)); /* If original and localized names are the same for other than English, * maybe localization failed. Try now in the main dialect. */ if(g_strcmp0(name, localized_name) == 0 && g_strcmp0(language->code, language->base_code) != 0) { g_free(localized_name); g_setenv("LANGUAGE", language->base_code, TRUE); setlocale (LC_ALL, language->base_code); localized_name = g_strdup(dgettext("iso_639", name)); } /* there might be several language names; use the first one */ char *semicolon = strchr(localized_name, ';'); if(semicolon) { char *tmp = localized_name; localized_name = g_strndup(localized_name, semicolon - localized_name); g_free(tmp); } // we initialize the name to the language code to have something on systems lacking iso-codes, so free it! g_free(language->name); language->name = g_strdup_printf("%s (%s)%s", localized_name, language->code, language->is_default ? " *" : ""); g_free(localized_name); // we can't break out of the loop here. at least pt is in our list twice! } } } else fprintf(stderr, "[l10n] error: element %d has no name, skipping\n", i); json_reader_end_element(reader); } json_reader_end_member(reader); // 639-2 end: // cleanup g_free(filename); if(error) g_error_free(error); if(reader) g_object_unref(reader); if(parser) g_object_unref(parser); #endif // HAVE_ISO_CODES }
static void restore_state(session_callback_type type, gpointer data, gpointer user_data) { JsonParser* jp = NULL; JsonReader* jr = NULL; const gchar* sqs; saved_state* s = NULL; GError* err = NULL; /* Is it the callback we're interested in? */ if (type != SPOP_SESSION_LOGGED_IN) return; /* First disable the callback so it's not called again */ session_remove_callback(restore_state, NULL); g_debug("savestate: reading saved state..."); s = g_new0(saved_state, 1); /* Read and parse state file */ jp = json_parser_new(); if (!json_parser_load_from_file(jp, g_state_file_path, &err)) { g_warning("savestate: error while reading state file: %s", err->message); goto restorestate_error; } jr = json_reader_new(json_parser_get_root(jp)); /* Read basic state */ if (!json_reader_read_member(jr, "status")) goto restorestate_jr_error; sqs = json_reader_get_string_value(jr); json_reader_end_member(jr); if (strcmp(sqs, "stopped")) s->qs = STOPPED; else if (strcmp(sqs, "playing")) s->qs = PLAYING; else if (strcmp(sqs, "paused")) s->qs = PAUSED; else { g_warning("savestate: bad value for queue status: %s", sqs); goto restorestate_error; } if (!json_reader_read_member(jr, "repeat")) goto restorestate_jr_error; s->repeat = json_reader_get_boolean_value(jr); json_reader_end_member(jr); if (!json_reader_read_member(jr, "shuffle")) goto restorestate_jr_error; s->shuffle = json_reader_get_boolean_value(jr); json_reader_end_member(jr); if (!json_reader_read_member(jr, "current_track")) goto restorestate_jr_error; s->cur_track = json_reader_get_int_value(jr); json_reader_end_member(jr); /* Now read tracks URIs */ if (!json_reader_read_member(jr, "tracks")) goto restorestate_jr_error; if (!json_reader_is_array(jr)) { g_warning("savestate: error while parsing JSON: tracks is not an array"); goto restorestate_error; } gint tracks = json_reader_count_elements(jr); if (s->cur_track >= tracks) { g_warning("savestate: incoherent state file: cur_track >= tracks"); goto restorestate_error; } s->tracks = g_array_sized_new(FALSE, FALSE, sizeof(sp_track*), tracks); if (!s->tracks) g_error("Can't allocate array of %d tracks.", tracks); size_t i; gboolean can_restore_now = TRUE; for (i=0; i < tracks; i++) { json_reader_read_element(jr, i); const gchar* uri = json_reader_get_string_value(jr); json_reader_end_element(jr); sp_link* lnk = sp_link_create_from_string(uri); sp_linktype lt = sp_link_type(lnk); if (lt != SP_LINKTYPE_TRACK) { g_warning("savestate: invalid link type for track %zu: %d", i, lt); sp_link_release(lnk); goto restorestate_error; } sp_track* tr = sp_link_as_track(lnk); sp_track_add_ref(tr); sp_link_release(lnk); g_array_append_val(s->tracks, tr); if (!sp_track_is_loaded(tr)) can_restore_now = FALSE; } /* If possible, restore now, else wait for all tracks to be loaded */ if (can_restore_now) really_restore_state(s); else { g_timeout_add(100, (GSourceFunc) really_restore_state, s); g_debug("savestate: waiting for all tracks to be loaded before restoring saved state..."); } /* Add a notification callback */ if (!interface_notify_add_callback(savestate_notification_callback, NULL)) g_error("Could not add savestate callback."); goto restorestate_clean; restorestate_jr_error: err = (GError*) json_reader_get_error(jr); g_warning("savestate: error while parsing JSON: %s", err->message); restorestate_error: if (s) { if (s->tracks) g_array_free(s->tracks, TRUE); g_free(s); } restorestate_clean: if (jp) g_object_unref(jp); if (jr) g_object_unref(jr); }
void getClips (JsonReader * reader, GESLayer * layer, GESTrackType type, gboolean absolute_paths) { int i; json_reader_read_member (reader, "clips"); g_print ("= clips =\n"); for (i = 0; i < json_reader_count_elements (reader); i++) { json_reader_read_element (reader, i); const char *src = getString (reader, "src"); int start = getInt (reader, "start"); int in = getInt (reader, "in"); int dur = getInt (reader, "dur"); g_print ("Clip: %s (start: %d, in: %d, dur: %d)\n", src, start, in, dur); GESClip *clip; if (is_in_members (reader, "multi") && getBool (reader, "multi")) { g_print ("multi on.\n"); clip = ges_multi_clip_from_path (src, layer, start, in, dur, absolute_paths); } else { const char *path; if (absolute_paths == TRUE) { path = src; } else { path = ges_renderer_get_absolute_path (src); } clip = ges_clip_from_path (path, layer, start, in, dur, type); } GESTimeline *tl = ges_layer_get_timeline (layer); GList *tracks = ges_timeline_get_tracks (tl); GESTrack *trackv = g_list_first (tracks)->data; GESTrack *tracka = g_list_last (tracks)->data; if (is_in_members (reader, "volume")) { double volume = getDouble (reader, "volume"); GESTrackElement *audioElement = ges_clip_find_track_element (clip, tracka, G_TYPE_NONE); if (audioElement != NULL) { ges_track_element_set_child_properties (audioElement, "volume", volume, NULL); } } GESTrackElement *videoElement = ges_clip_find_track_element (clip, trackv, G_TYPE_NONE); if (videoElement != NULL) { if (is_in_members (reader, "x")) { int x = getInt (reader, "x"); ges_track_element_set_child_properties (videoElement, "posx", x, NULL); } if (is_in_members (reader, "y")) { int y = getInt (reader, "y"); ges_track_element_set_child_properties (videoElement, "posy", y, NULL); } if (is_in_members (reader, "alpha")) { gdouble alpha = getDouble (reader, "alpha"); ges_track_element_set_child_properties (videoElement, "alpha", alpha, NULL); } if (is_in_members (reader, "size")) { gdouble size = getDouble (reader, "size"); GESUriClipAsset *asset = GES_URI_CLIP_ASSET (ges_extractable_get_asset (GES_EXTRACTABLE (clip))); guint width = ges_asset_get_width (asset); guint height = ges_asset_get_height (asset); if (width != 0 && height != 0) { double dw = width * size; double dh = height * size; g_print ("%dx%d => * %f => %dx%d\n", width, height, size, (int) dw, (int) dh); ges_track_element_set_child_properties (videoElement, "width", (int) dw, "height", (int) dh, NULL); } } if (is_in_members (reader, "effect")) { const char *effect_str = getString (reader, "effect"); if (strcmp (effect_str, "") != 0) { g_print ("Using effect %s", effect_str); GESEffect *effect = ges_effect_new (effect_str); ges_container_add (GES_CONTAINER (clip), GES_TIMELINE_ELEMENT (effect)); } } } json_reader_end_element (reader); } json_reader_end_member (reader); }
void render_json (const char *filename) { JsonParser *parser; JsonNode *root; GError *error; parser = json_parser_new (); error = NULL; json_parser_load_from_file (parser, filename, &error); if (error) { g_print ("Parsing error `%s':\n %s\n", filename, error->message); g_error_free (error); g_object_unref (parser); exit (0); } root = json_parser_get_root (parser); JsonReader *reader = json_reader_new (root); GESTimeline *timeline; json_reader_read_member (reader, "composition"); // comp strings const char *name = getString (reader, "name"); //const char *src_dir = getString (reader, "src-dir"); //g_print ("Source Directory: %s\nName: %s\n", src_dir, name); // comp ints int width = getInt (reader, "width"); int height = getInt (reader, "height"); int fps = getInt (reader, "fps"); gboolean transparency = TRUE; if (is_in_members (reader, "transparency")) { transparency = getBool (reader, "transparency"); } gboolean absolute_paths = FALSE; if (is_in_members (reader, "absolute_paths")) { absolute_paths = getBool (reader, "absolute_paths"); } g_print ("Resolution: %dx%d, FPS: %d\n", width, height, fps); timeline = ges_timeline_new_audio_video (); int i; json_reader_read_member (reader, "layers"); for (i = 0; i < json_reader_count_elements (reader); i++) { json_reader_read_element (reader, i); GESLayer *layer = ges_layer_new (); g_object_set (layer, "priority", i, NULL); if (is_in_members (reader, "autotransition")) { gboolean autotransition = getBool (reader, "autotransition"); if (autotransition) g_print ("Auto Transitions on.\n"); g_object_set (layer, "auto-transition", autotransition, NULL); } ges_timeline_add_layer (timeline, layer); getClips (reader, layer, GES_TRACK_TYPE_UNKNOWN, absolute_paths); json_reader_end_element (reader); } json_reader_end_member (reader); ges_timeline_commit (timeline); const gchar *xges_path = g_strconcat ("file://", filename, ".xges", NULL); ges_timeline_save_xges (timeline, xges_path); //free(xges_path); // formats GESRendererProfile res = { width, height, fps, PROFILE_AAC_H264_QUICKTIME, NULL }; if (!transparency) { g_print ("Deactivating transparency\n"); res.format = "I420"; } json_reader_read_member (reader, "formats"); for (i = 0; i < json_reader_count_elements (reader); i++) { json_reader_read_element (reader, i); const char *format = json_reader_get_string_value (reader); json_reader_end_element (reader); g_print ("format: %s\n", format); EncodingProfile prof = PROFILE_AAC_H264_QUICKTIME; if (strcmp (format, "webm") == 0) { prof = PROFILE_VORBIS_VP8_WEBM; } else if (strcmp (format, "mkv") == 0) { prof = PROFILE_VORBIS_H264_MATROSKA; } else if (strcmp (format, "mp4") == 0) { prof = PROFILE_AAC_H264_QUICKTIME; } else if (strcmp (format, "ogg") == 0) { prof = PROFILE_VORBIS_THEORA_OGG; } res.profile = prof; ges_renderer_render (timeline, name, &res, absolute_paths); } json_reader_end_member (reader); json_reader_end_member (reader); g_object_unref (reader); g_object_unref (parser); }