From 150878c84ae93915bdf5909c826b4c9fe4a1b392 Mon Sep 17 00:00:00 2001 From: Martyn Russell Date: Wed, 10 Sep 2014 15:27:33 +0100 Subject: extract: Add async APIs for all functions https://bugzilla.gnome.org/show_bug.cgi?id=724879 --- libmediaart/extract.c | 895 +++++++++++++++++++++++++++++++++++++++----------- libmediaart/extract.h | 98 ++++-- tests/mediaarttest.c | 493 ++++++++++++++++----------- 3 files changed, 1062 insertions(+), 424 deletions(-) diff --git a/libmediaart/extract.c b/libmediaart/extract.c index faaf994..a82b007 100644 --- a/libmediaart/extract.c +++ b/libmediaart/extract.c @@ -103,6 +103,21 @@ typedef enum { IMAGE_MATCH_TYPE_COUNT } ImageMatchType; +typedef struct { + MediaArtType type; + MediaArtProcessFlags flags; + + GFile *file; + gchar *uri; + + unsigned char *buffer; + size_t len; + gchar *mime; + + gchar *artist; + gchar *title; +} ProcessData; + static void media_art_queue_cb (GObject *source_object, GAsyncResult *res, gpointer user_data); @@ -304,63 +319,86 @@ file_get_checksum_if_exists (GChecksumType checksum_type, const gchar *path, gchar **md5, gboolean check_jpeg, - gboolean *is_jpeg) + gboolean *is_jpeg, + GError **error) { - GFile *file = g_file_new_for_path (path); + GFile *file; GFileInputStream *stream; GChecksum *checksum; - gboolean retval; + GError *local_error = NULL; + gssize rsize; + guchar buffer[1024]; + gboolean stop; + + file = g_file_new_for_path (path); + stream = g_file_read (file, NULL, &local_error); + + if (local_error) { + g_object_unref (file); + g_propagate_error (error, local_error); + return FALSE; + } + + if (!stream) { + g_set_error (error, + g_io_error_quark (), + G_IO_ERROR_FAILED, + "Could not calculate MD5 checksum for '%s', g_file_read() gave no error either?!", + path); + g_object_unref (file); + return FALSE; + } checksum = g_checksum_new (checksum_type); if (!checksum) { - g_debug ("Can't create checksum engine"); + g_set_error (error, + g_io_error_quark (), + G_IO_ERROR_FAILED, + "Could not calculate MD5 checksum for '%s', g_checksum_new() failed", + path); g_object_unref (file); + g_object_unref (stream); return FALSE; } - stream = g_file_read (file, NULL, NULL); - - if (stream) { - gssize rsize; - guchar buffer[1024]; - - /* File exists & readable always means true retval */ - retval = TRUE; - - if (check_jpeg) { - if (g_input_stream_read_all (G_INPUT_STREAM (stream), - buffer, - 3, - (gsize *) &rsize, - NULL, - NULL)) { - if (rsize >= 3 && - buffer[0] == 0xff && - buffer[1] == 0xd8 && - buffer[2] == 0xff) { - if (is_jpeg) { - *is_jpeg = TRUE; - } - - /* Add the read bytes to the checksum */ - g_checksum_update (checksum, buffer, rsize); - } else { - /* Larger than 3 bytes but incorrect jpeg header */ - if (is_jpeg) { - *is_jpeg = FALSE; - } - goto end; + /* File exists & readable always means true retval */ + if (check_jpeg) { + if (g_input_stream_read_all (G_INPUT_STREAM (stream), + buffer, + 3, + (gsize *) &rsize, + NULL, + NULL)) { + if (rsize >= 3 && + buffer[0] == 0xff && + buffer[1] == 0xd8 && + buffer[2] == 0xff) { + if (is_jpeg) { + *is_jpeg = TRUE; } + + /* Add the read bytes to the checksum */ + g_checksum_update (checksum, buffer, rsize); } else { - /* Smaller than 3 bytes, not a jpeg */ + /* Larger than 3 bytes but incorrect jpeg header */ if (is_jpeg) { *is_jpeg = FALSE; } - goto end; + + stop = TRUE; } + } else { + /* Smaller than 3 bytes, not a jpeg */ + if (is_jpeg) { + *is_jpeg = FALSE; + } + + stop = TRUE; } + } + if (!stop) { while ((rsize = g_input_stream_read (G_INPUT_STREAM (stream), buffer, 1024, @@ -372,22 +410,13 @@ file_get_checksum_if_exists (GChecksumType checksum_type, if (md5) { *md5 = g_strdup (g_checksum_get_string (checksum)); } - - } else { - g_debug ("%s isn't readable while calculating MD5 checksum", path); - /* File doesn't exist or isn't readable */ - retval = FALSE; - } - -end: - if (stream) { - g_object_unref (stream); } + g_object_unref (stream); g_checksum_free (checksum); g_object_unref (file); - return retval; + return TRUE; } static gboolean @@ -397,17 +426,24 @@ convert_from_other_format (const gchar *found, const gchar *artist, GError **error) { + GError *local_error = NULL; gboolean retval; gchar *sum1 = NULL; + gchar *sum2 = NULL; gchar *target_temp; target_temp = g_strdup_printf ("%s-tmp", target); - if (!media_art_file_to_jpeg (found, target_temp, error)) { + media_art_file_to_jpeg (found, target_temp, &local_error); + + if (local_error) { + g_propagate_error (error, local_error); + g_unlink (target_temp); g_free (target_temp); return FALSE; } + /* If artist doesn't exist, try to rename temp file to album path */ if (artist == NULL || g_strcmp0 (artist, " ") == 0) { retval = g_rename (target_temp, album_path) == 0; @@ -419,72 +455,68 @@ convert_from_other_format (const gchar *found, target_temp, album_path, g_strerror (errno)); + g_unlink (target_temp); } - g_debug ("rename(%s, %s) error: %s", + g_debug ("Renaming ('%s' --> '%s'), %s", target_temp, album_path, - g_strerror (errno)); - } else if (file_get_checksum_if_exists (G_CHECKSUM_MD5, - target_temp, - &sum1, - FALSE, - NULL)) { - gchar *sum2 = NULL; - - if (file_get_checksum_if_exists (G_CHECKSUM_MD5, - album_path, - &sum2, - FALSE, - NULL)) { - if (g_strcmp0 (sum1, sum2) == 0) { - - /* If album-space-md5.jpg is the same as found, - * make a symlink */ - retval = symlink (album_path, target) == 0; - - if (!retval) { - g_set_error (error, - media_art_error_quark (), - MEDIA_ART_ERROR_RENAME_FAILED, - "Could not rename '%s' to '%s': %s", - album_path, - target, - g_strerror (errno)); - } + !retval ? g_strerror (errno) : "no error given"); - g_debug ("symlink(%s, %s) error: %s", - album_path, - target, - g_strerror (errno)); + g_free (target_temp); - g_unlink (target_temp); - } else { + return retval; + } - /* If album-space-md5.jpg isn't the same as found, - * make a new album-md5-md5.jpg (found -> target) */ - retval = g_rename (target_temp, album_path) == 0; - - if (!retval) { - g_set_error (error, - media_art_error_quark (), - MEDIA_ART_ERROR_RENAME_FAILED, - "Could not rename '%s' to '%s': %s", - target_temp, - album_path, - g_strerror (errno)); - } + /* Checksum both temp file and album path and decide what to + * do base on what we find... + */ + file_get_checksum_if_exists (G_CHECKSUM_MD5, + target_temp, + &sum1, + FALSE, + NULL, + &local_error); + + if (local_error) { + g_propagate_error (error, local_error); + g_unlink (target_temp); + g_free (target_temp); + return FALSE; + } + + file_get_checksum_if_exists (G_CHECKSUM_MD5, + album_path, + &sum2, + FALSE, + NULL, + &local_error); - g_debug ("rename(%s, %s) error: %s", - target_temp, - album_path, - g_strerror (errno)); + if (!local_error) { + if (g_strcmp0 (sum1, sum2) == 0) { + /* If album-space-md5.jpg is the same as found, + * make a symlink */ + retval = symlink (album_path, target) == 0; + + if (!retval) { + g_set_error (error, + media_art_error_quark (), + MEDIA_ART_ERROR_RENAME_FAILED, + "Could not rename '%s' to '%s': %s", + album_path, + target, + g_strerror (errno)); } - g_free (sum2); + g_debug ("Creating symlink ('%s' --> '%s'), %s", + album_path, + target, + !retval ? g_strerror (errno) : "no error given"); + + g_unlink (target_temp); } else { - /* If there's not yet a album-space-md5.jpg, make one, - * and symlink album-md5-md5.jpg to it */ + /* If album-space-md5.jpg isn't the same as found, + * make a new album-md5-md5.jpg (found -> target) */ retval = g_rename (target_temp, album_path) == 0; if (!retval) { @@ -492,36 +524,56 @@ convert_from_other_format (const gchar *found, media_art_error_quark (), MEDIA_ART_ERROR_RENAME_FAILED, "Could not rename '%s' to '%s': %s", + target_temp, album_path, - target, g_strerror (errno)); - } else { - retval = symlink (album_path, target) == 0; - - if (!retval) { - g_set_error (error, - media_art_error_quark (), - MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not rename '%s' to '%s': %s", - album_path, - target, - g_strerror (errno)); - } - - g_debug ("symlink(%s,%s) error: %s", - album_path, - target, - g_strerror (errno)); } + + g_debug ("Renaming ('%s' --> '%s'), %s", + target_temp, + album_path, + !retval ? g_strerror (errno) : "no error given"); } - g_free (sum1); + g_free (sum2); } else { - g_debug ("Can't read %s while calculating checksum", target_temp); - /* Can't read the file that it was converted to, strange ... */ - g_unlink (target_temp); + g_clear_error (&local_error); + + /* If there's not yet a album-space-md5.jpg, make one, + * and symlink album-md5-md5.jpg to it */ + retval = g_rename (target_temp, album_path) == 0; + + if (!retval) { + g_set_error (error, + media_art_error_quark (), + MEDIA_ART_ERROR_RENAME_FAILED, + "Could not rename '%s' to '%s': %s", + album_path, + target, + g_strerror (errno)); + + g_unlink (target_temp); + } else { + retval = symlink (album_path, target) == 0; + + if (!retval) { + g_set_error (error, + media_art_error_quark (), + MEDIA_ART_ERROR_SYMLINK_FAILED, + "Could not rename '%s' to '%s': %s", + album_path, + target, + g_strerror (errno)); + } + + g_debug ("Creating symlink ('%s' --> '%s'), %s", + album_path, + target, + !retval ? g_strerror (errno) : "no error given"); + } } + g_free (sum1); g_free (target_temp); return retval; @@ -798,6 +850,7 @@ get_heuristic (MediaArtType type, if (g_str_has_suffix (art_file_path, "jpeg") || g_str_has_suffix (art_file_path, "jpg")) { + GError *local_error = NULL; gboolean is_jpeg = FALSE; gchar *sum1 = NULL; @@ -805,7 +858,6 @@ get_heuristic (MediaArtType type, (artist == NULL || g_strcmp0 (artist, " ") == 0)) { GFile *art_file; GFile *target_file; - GError *local_error = NULL; g_debug ("Album art (JPEG) found in same directory being used:'%s'", art_file_path); @@ -832,7 +884,8 @@ get_heuristic (MediaArtType type, art_file_path, &sum1, TRUE, - &is_jpeg)) { + &is_jpeg, + &local_error)) { /* Avoid duplicate artwork for each track in an album */ media_art_get_path (NULL, title_stripped, @@ -850,7 +903,8 @@ get_heuristic (MediaArtType type, album_art_file_path, &sum2, FALSE, - NULL)) { + NULL, + &local_error)) { if (g_strcmp0 (sum1, sum2) == 0) { /* If album-space-md5.jpg is the same as found, * make a symlink */ @@ -860,13 +914,13 @@ get_heuristic (MediaArtType type, g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not link '%s' to '%s': %s", + "Could not symlink '%s' to '%s', %s", album_art_file_path, target, g_strerror (errno)); } - g_debug ("symlink(%s, %s) error: %s", + g_debug ("symlink('%s' --> '%s'), %s", album_art_file_path, target, g_strerror (errno)); @@ -884,7 +938,11 @@ get_heuristic (MediaArtType type, NULL, NULL, NULL, - error); + &local_error); + + if (local_error) { + g_propagate_error (error, local_error); + } g_object_unref (art_file); g_object_unref (target_file); @@ -895,6 +953,8 @@ get_heuristic (MediaArtType type, GFile *art_file; GFile *album_art_file; + g_clear_error (&local_error); + /* If there's not yet a album-space-md5.jpg, make one, * and symlink album-md5-md5.jpg to it */ album_art_file = g_file_new_for_path (album_art_file_path); @@ -905,22 +965,24 @@ get_heuristic (MediaArtType type, NULL, NULL, NULL, - error); + &local_error); - if (retval) { + if (local_error) { + g_propagate_error (error, local_error); + } else { retval = symlink (album_art_file_path, target) == 0; if (!retval) { g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not link '%s' to '%s': %s", + "Could not symlink '%s' to '%s', %s", album_art_file_path, target, g_strerror (errno)); } - g_debug ("symlink(%s, %s) error: %s", + g_debug ("symlink('%s' --> '%s'), %s", album_art_file_path, target, g_strerror (errno)); } @@ -940,6 +1002,7 @@ get_heuristic (MediaArtType type, g_free (sum1); } else { /* Can't read contents of the cover.jpg file ... */ + g_propagate_error (error, local_error); retval = FALSE; } } else if (g_str_has_suffix (art_file_path, "png")) { @@ -1002,6 +1065,7 @@ media_art_set (const unsigned char *buffer, const gchar *title, GError **error) { + GError *local_error = NULL; gchar *local_path; gchar *album_path; gchar *md5_album = NULL; @@ -1048,10 +1112,19 @@ media_art_set (const unsigned char *buffer, * i) save buffer to jpeg only. */ if (type != MEDIA_ART_ALBUM || (artist == NULL || g_strcmp0 (artist, " ") == 0)) { - retval = media_art_buffer_to_jpeg (buffer, len, mime, local_path, error); - g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s'", len, local_path); + retval = media_art_buffer_to_jpeg (buffer, len, mime, local_path, &local_error); + + g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s', %s", + len, + local_path, + local_error ? local_error->message : "no error given"); g_free (local_path); + if (local_error) { + g_propagate_error (error, local_error); + return FALSE; + } + return retval; } @@ -1067,11 +1140,17 @@ media_art_set (const unsigned char *buffer, NULL); if (!g_file_test (album_path, G_FILE_TEST_EXISTS)) { - retval = TRUE; + media_art_buffer_to_jpeg (buffer, len, mime, album_path, &local_error); - if (media_art_buffer_to_jpeg (buffer, len, mime, album_path, error)) { - g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s'", len, album_path); + g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s', %s", + len, + local_path, + local_error ? local_error->message : "no error given"); + if (local_error) { + g_propagate_error (error, local_error); + retval = FALSE; + } else { /* If album-space-md5.jpg doesn't * exist, make one and make a symlink * to album-md5-md5.jpg @@ -1082,7 +1161,7 @@ media_art_set (const unsigned char *buffer, g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not link '%s' to '%s': %s", + "Could not symlink '%s' to '%s', %s", album_path, local_path, g_strerror (errno)); @@ -1100,16 +1179,21 @@ media_art_set (const unsigned char *buffer, return retval; } - if (!file_get_checksum_if_exists (G_CHECKSUM_MD5, - album_path, - &md5_album, - FALSE, - NULL)) { - g_debug ("No MD5 checksum found for album path:'%s'", album_path); + file_get_checksum_if_exists (G_CHECKSUM_MD5, + album_path, + &md5_album, + FALSE, + NULL, + &local_error); + + if (local_error) { + g_debug ("%s", local_error->message); + g_propagate_error (error, local_error); g_free (album_path); g_free (local_path); + /* FIXME: Is it right to return TRUE here ?*/ return TRUE; } @@ -1133,7 +1217,7 @@ media_art_set (const unsigned char *buffer, g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not link '%s' to '%s': %s", + "Could not symlink '%s' to '%s', %s", album_path, local_path, g_strerror (errno)); @@ -1147,8 +1231,17 @@ media_art_set (const unsigned char *buffer, /* If album-space-md5.jpg isn't the same as * buffer, make a new album-md5-md5.jpg */ - retval = media_art_buffer_to_jpeg (buffer, len, mime, local_path, error); - g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s'", len, local_path); + retval = media_art_buffer_to_jpeg (buffer, len, mime, local_path, &local_error); + + g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s', %s", + len, + local_path, + local_error ? local_error->message : "no error given"); + + if (local_error) { + g_propagate_error (error, local_error); + retval = FALSE; + } } g_free (md5_data); @@ -1166,10 +1259,18 @@ media_art_set (const unsigned char *buffer, * cache, unlink it... */ temp = g_strdup_printf ("%s-tmp", album_path); + media_art_buffer_to_jpeg (buffer, len, mime, temp, &local_error); - /* If buffer isn't a JPEG */ - if (!media_art_buffer_to_jpeg (buffer, len, mime, temp, error)) { - /* Can't read temp file ... */ + g_debug ("Saving buffer to jpeg (%ld bytes) --> '%s', %s", + len, + local_path, + local_error ? local_error->message : "no error given"); + + if (local_error) { + g_propagate_error (error, local_error); + + /* Unlink in case there was some error and half the + * job was done. */ g_unlink (temp); g_free (temp); @@ -1180,11 +1281,14 @@ media_art_set (const unsigned char *buffer, return FALSE; } - if (file_get_checksum_if_exists (G_CHECKSUM_MD5, - temp, - &md5_tmp, - FALSE, - NULL)) { + file_get_checksum_if_exists (G_CHECKSUM_MD5, + temp, + &md5_tmp, + FALSE, + NULL, + &local_error); + + if (!local_error) { if (g_strcmp0 (md5_tmp, md5_album) == 0) { /* If album-space-md5.jpg is the same as * buffer, make a symlink to album-md5-md5.jpg @@ -1195,7 +1299,7 @@ media_art_set (const unsigned char *buffer, g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_SYMLINK_FAILED, - "Could not link '%s' to '%s': %s", + "Could not symlink '%s' to '%s', %s", album_path, local_path, g_strerror (errno)); @@ -1215,7 +1319,7 @@ media_art_set (const unsigned char *buffer, g_set_error (error, media_art_error_quark (), MEDIA_ART_ERROR_RENAME_FAILED, - "Could not rename '%s' to '%s': %s", + "Could not rename '%s' to '%s', %s", temp, local_path, g_strerror (errno)); @@ -1228,6 +1332,10 @@ media_art_set (const unsigned char *buffer, } g_free (md5_tmp); + } else { + g_debug ("%s", local_error->message); + g_propagate_error (error, local_error); + retval = FALSE; } /* Clean up */ @@ -1507,6 +1615,113 @@ get_heuristic_for_parent_path (GFile *file, return key; } +static ProcessData * +process_data_new (MediaArtType type, + MediaArtProcessFlags flags, + GFile *file, + const gchar *uri, + const unsigned char *buffer, + size_t len, + const gchar *mime, + const gchar *artist, + const gchar *title) +{ + ProcessData *data; + + data = g_slice_new0 (ProcessData); + data->type = type; + data->flags = flags; + + if (file) { + data->file = g_object_ref (file); + } + + data->uri = g_strdup (uri); + + data->buffer = g_memdup (buffer, data->len); + data->len = len; + data->mime = g_strdup (mime); + + data->artist = g_strdup (artist); + data->title = g_strdup (title); + + return data; +} + +static void +process_data_free (ProcessData *data) +{ + if (!data) { + return; + } + + if (data->file) { + g_object_unref (data->file); + } + + g_free (data->uri); + + g_free (data->buffer); + g_free (data->mime); + + g_free (data->artist); + g_free (data->title); + + g_slice_free (ProcessData, data); +} + +static void +process_thread (GTask *task, + gpointer source_object, + gpointer task_data, + GCancellable *cancellable) +{ + MediaArtProcess *process = MEDIA_ART_PROCESS (source_object); + ProcessData *data = task_data; + GError *error = NULL; + gboolean success = FALSE; + + if (!g_cancellable_set_error_if_cancelled (cancellable, &error)) { + if (data->file) { + success = media_art_process_file (process, + data->type, + data->flags, + data->file, + data->artist, + data->title, + cancellable, + &error); + } else if (data->uri) { + success = media_art_process_uri (process, + data->type, + data->flags, + data->uri, + data->artist, + data->title, + cancellable, + &error); + } else { + success = media_art_process_buffer (process, + data->type, + data->flags, + data->file, + data->buffer, + data->len, + data->mime, + data->artist, + data->title, + cancellable, + &error); + } + } + + if (error) { + g_task_return_error (task, error); + } else { + g_task_return_boolean (task, success); + } +} + /** * media_art_process_buffer: * @process: Media art process object @@ -1518,7 +1733,10 @@ get_heuristic_for_parent_path (GFile *file, * @mime: MIME type of @buffer, or %NULL * @artist: (allow-none): The artist name @file or %NULL * @title: (allow-none): The title for @file or %NULL - * @error: Pointer to potential GLib / MediaArt error, or %NULL + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore + * @error: a #GError location to store the error occurring, or %NULL + * to ignore. * * Processes a memory buffer represented by @buffer and @len. If you * have extracted any embedded media art and passed this in as @@ -1544,6 +1762,7 @@ media_art_process_buffer (MediaArtProcess *process, const gchar *mime, const gchar *artist, const gchar *title, + GCancellable *cancellable, GError **error) { GFile *cache_art_file, *local_art_file; @@ -1591,6 +1810,11 @@ media_art_process_buffer (MediaArtProcess *process, cache_mtime = get_mtime (cache_art_file, &local_error); + if (g_cancellable_set_error_if_cancelled (cancellable, error)) { + g_free (uri); + return FALSE; + } + if (local_error && local_error->domain == g_io_error_quark () && local_error->code == G_IO_ERROR_NOT_FOUND) { @@ -1636,16 +1860,18 @@ media_art_process_buffer (MediaArtProcess *process, processed = TRUE; } - if (local_art_file && !g_file_query_exists (local_art_file, NULL)) { - /* We can't reuse art_exists here because the - * situation might have changed - */ - if (g_file_query_exists (cache_art_file, NULL)) { - gchar *local_art_uri; + if (!g_cancellable_set_error_if_cancelled (cancellable, error)) { + if (local_art_file && !g_file_query_exists (local_art_file, NULL)) { + /* We can't reuse art_exists here because the + * situation might have changed + */ + if (g_file_query_exists (cache_art_file, NULL)) { + gchar *local_art_uri; - local_art_uri = g_file_get_uri (local_art_file); - media_art_copy_to_local (process, cache_art_path, local_art_uri); - g_free (local_art_uri); + local_art_uri = g_file_get_uri (local_art_file); + media_art_copy_to_local (process, cache_art_path, local_art_uri); + g_free (local_art_uri); + } } } @@ -1660,9 +1886,101 @@ media_art_process_buffer (MediaArtProcess *process, g_free (cache_art_path); g_free (uri); + if (g_cancellable_is_cancelled (cancellable)) { + processed = FALSE; + } + return processed; } +/** + * media_art_process_buffer_async: + * @process: Media art process object + * @type: The type of media + * @flags: The options given for how to process the media art + * @related_file: File related to the media art + * @buffer: (array length=len)(allow-none): a buffer containing @file + * data, or %NULL + * @len: length of @buffer, or 0 + * @mime: MIME type of @buffer, or %NULL + * @artist: (allow-none): The artist name @file or %NULL + * @title: (allow-none): The title for @file or %NULL + * @io_priority: the [I/O priority][io-priority] of the request + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore + * @callback: (scope async): a #GAsyncReadyCallback to call when the + * request is satisfied + * @user_data: (closure): the data to pass to callback function + * + * Processes media art. Precisely the same operation as + * media_art_process_buffer() is performing, but asynchronously. + * + * When all i/o for the operation is finished the @callback will be + * called. + * + * In case of a partial error the callback will be called with any + * succeeding items and no error, and on the next request the error + * will be reported. If a request is cancelled the callback will be + * called with %G_IO_ERROR_CANCELLED. + * + * Dbufferng an async request no other sync and async calls are allowed, + * and will result in %G_IO_ERROR_PENDING errors. + * + * Any outstanding i/o request with higher priority (lower numerical + * value) will be executed before an outstanding request with lower + * priority. Default priority is %G_PRIORITY_DEFAULT. + * + * Since: 0.7.0 + */ +void +media_art_process_buffer_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *related_file, + const guchar *buffer, + gsize len, + const gchar *mime, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GTask *task; + + task = g_task_new (process, cancellable, callback, user_data); + g_task_set_task_data (task, process_data_new (type, flags, related_file, NULL, buffer, len, mime, artist, title), (GDestroyNotify) process_data_free); + g_task_set_priority (task, io_priority); + g_task_run_in_thread (task, process_thread); + g_object_unref (task); +} + +/** + * media_art_process_buffer_finish: + * @process: the #MediaArtProcess + * @result: a #GAsyncResult. + * @error: a #GError location to store the error occurring, or %NULL + * to ignore. + * + * Finishes the asynchronous operation started with + * media_art_process_file_async(). + * + * Returns: %TRUE on success, otherwise %FALSE when @error will be set. + * + * Since: 0.7.0 + **/ +gboolean +media_art_process_buffer_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error) +{ + g_return_val_if_fail (g_task_is_valid (result, process), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); + +} + /** * media_art_process_file: * @process: Media art process object @@ -1671,7 +1989,10 @@ media_art_process_buffer (MediaArtProcess *process, * @file: File to be processed * @artist: (allow-none): The artist name @file or %NULL * @title: (allow-none): The title for @file or %NULL - * @error: Pointer to potential GLib / MediaArt error, or %NULL + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore + * @error: a #GError location to store the error occurring, or %NULL + * to ignore. * * Process @file and check if media art exists and if it is up to date * with @artist and @title provided. Either @artist OR @title can be @@ -1712,6 +2033,7 @@ media_art_process_file (MediaArtProcess *process, GFile *file, const gchar *artist, const gchar *title, + GCancellable *cancellable, GError **error) { MediaArtProcessPrivate *private; @@ -1747,6 +2069,11 @@ media_art_process_file (MediaArtProcess *process, return FALSE; } + if (g_cancellable_set_error_if_cancelled (cancellable, error)) { + g_free (uri); + return FALSE; + } + media_art_get_file (artist, title, media_art_type_name[type], @@ -1766,32 +2093,37 @@ media_art_process_file (MediaArtProcess *process, key = get_heuristic_for_parent_path (file, type, artist, title); if (!g_hash_table_lookup (private->media_art_cache, key)) { - gchar *local_art_uri; - - local_art_uri = g_file_get_uri (local_art_file); - - if (!get_heuristic (type, uri, local_art_uri, artist, title, error)) { - /* If the heuristic failed, we - * request the download the - * media-art to the media-art - * downloaders - */ - media_art_request_download (process, - type, - artist, - title, - local_art_uri, - cache_art_path); - - /* FIXME: Should return TRUE or FALSE? */ - } + /* Check we're not cancelled before + * potentially trying a download operation. + */ + if (!g_cancellable_set_error_if_cancelled (cancellable, error)) { + gchar *local_art_uri; + + local_art_uri = g_file_get_uri (local_art_file); + + if (!get_heuristic (type, uri, local_art_uri, artist, title, error)) { + /* If the heuristic failed, we + * request the download the + * media-art to the media-art + * downloaders + */ + media_art_request_download (process, + type, + artist, + title, + local_art_uri, + cache_art_path); + + /* FIXME: Should return TRUE or FALSE? */ + } - set_mtime (cache_art_path, mtime); + set_mtime (cache_art_path, mtime); - g_hash_table_insert (private->media_art_cache, - key, - GINT_TO_POINTER(TRUE)); - g_free (local_art_uri); + g_hash_table_insert (private->media_art_cache, + key, + GINT_TO_POINTER(TRUE)); + g_free (local_art_uri); + } } else { g_free (key); } @@ -1812,7 +2144,89 @@ media_art_process_file (MediaArtProcess *process, g_free (cache_art_path); g_free (uri); - return TRUE; + return !g_cancellable_is_cancelled (cancellable); +} + + +/** + * media_art_process_file_async: + * @process: Media art process object + * @type: The type of media + * @flags: The options given for how to process the media art + * @file: File to be processed + * @artist: (allow-none): The artist name @file or %NULL + * @title: (allow-none): The title for @file or %NULL + * @io_priority: the [I/O priority][io-priority] of the request + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore + * @callback: (scope async): a #GAsyncReadyCallback to call when the + * request is satisfied + * @user_data: (closure): the data to pass to callback function + * + * Processes media art. Precisely the same operation as + * media_art_process_file() is performing, but asynchronously. + * + * When all i/o for the operation is finished the @callback will be + * called. + * + * In case of a partial error the callback will be called with any + * succeeding items and no error, and on the next request the error + * will be reported. If a request is cancelled the callback will be + * called with %G_IO_ERROR_CANCELLED. + * + * During an async request no other sync and async calls are allowed, + * and will result in %G_IO_ERROR_PENDING errors. + * + * Any outstanding i/o request with higher priority (lower numerical + * value) will be executed before an outstanding request with lower + * priority. Default priority is %G_PRIORITY_DEFAULT. + * + * Since: 0.7.0 + */ +void +media_art_process_file_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *file, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GTask *task; + + task = g_task_new (process, cancellable, callback, user_data); + g_task_set_task_data (task, process_data_new (type, flags, file, NULL, NULL, 0, NULL, artist, title), (GDestroyNotify) process_data_free); + g_task_set_priority (task, io_priority); + g_task_run_in_thread (task, process_thread); + g_object_unref (task); +} + +/** + * media_art_process_file_finish: + * @process: the #MediaArtProcess + * @result: a #GAsyncResult. + * @error: a #GError location to store the error occurring, or %NULL + * to ignore. + * + * Finishes the asynchronous operation started with + * media_art_process_file_async(). + * + * Returns: %TRUE on success, otherwise %FALSE when @error will be set. + * + * Since: 0.7.0 + **/ +gboolean +media_art_process_file_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error) +{ + g_return_val_if_fail (g_task_is_valid (result, process), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); + } /** @@ -1823,6 +2237,8 @@ media_art_process_file (MediaArtProcess *process, * @uri: URI of the media file that contained the data * @artist: (allow-none): The artist name @uri or %NULL * @title: (allow-none): The title for @uri or %NULL + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore * @error: Pointer to potential GLib / MediaArt error, or %NULL * * This function calls media_art_process_file(), but takes the @uri as @@ -1840,6 +2256,7 @@ media_art_process_uri (MediaArtProcess *process, const gchar *uri, const gchar *artist, const gchar *title, + GCancellable *cancellable, GError **error) { GFile *file; @@ -1858,9 +2275,91 @@ media_art_process_uri (MediaArtProcess *process, file, artist, title, + cancellable, error); g_object_unref (file); return result; } + +/** + * media_art_process_uri_async: + * @process: Media art process object + * @type: The type of media + * @flags: The options given for how to process the media art + * @uri: A string representing a URI to be processed + * @artist: (allow-none): The artist name @file or %NULL + * @title: (allow-none): The title for @file or %NULL + * @io_priority: the [I/O priority][io-priority] of the request + * @cancellable: (allow-none): optional #GCancellable object, %NULL to + * ignore + * @callback: (scope async): a #GAsyncReadyCallback to call when the + * request is satisfied + * @user_data: (closure): the data to pass to callback function + * + * Processes media art. Precisely the same operation as + * media_art_process_uri() is performing, but asynchronously. + * + * When all i/o for the operation is finished the @callback will be + * called. + * + * In case of a partial error the callback will be called with any + * succeeding items and no error, and on the next request the error + * will be reported. If a request is cancelled the callback will be + * called with %G_IO_ERROR_CANCELLED. + * + * During an async request no other sync and async calls are allowed, + * and will result in %G_IO_ERROR_PENDING errors. + * + * Any outstanding i/o request with higher priority (lower numerical + * value) will be executed before an outstanding request with lower + * priority. Default priority is %G_PRIORITY_DEFAULT. + * + * Since: 0.7.0 + */ +void +media_art_process_uri_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + const gchar *uri, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data) +{ + GTask *task; + + task = g_task_new (process, cancellable, callback, user_data); + g_task_set_task_data (task, process_data_new (type, flags, NULL, uri, NULL, 0, NULL, artist, title), (GDestroyNotify) process_data_free); + g_task_set_priority (task, io_priority); + g_task_run_in_thread (task, process_thread); + g_object_unref (task); +} + +/** + * media_art_process_uri_finish: + * @process: the #MediaArtProcess + * @result: a #GAsyncResult. + * @error: a #GError location to store the error occurring, or %NULL + * to ignore. + * + * Finishes the asynchronous operation started with + * media_art_process_file_async(). + * + * Returns: %TRUE on success, otherwise %FALSE when @error will be set. + * + * Since: 0.7.0 + **/ +gboolean +media_art_process_uri_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error) +{ + g_return_val_if_fail (g_task_is_valid (result, process), FALSE); + + return g_task_propagate_boolean (G_TASK (result), error); + +} diff --git a/libmediaart/extract.h b/libmediaart/extract.h index 2356790..c01d2cb 100644 --- a/libmediaart/extract.h +++ b/libmediaart/extract.h @@ -129,32 +129,78 @@ struct _MediaArtProcessClass { }; -GType media_art_process_get_type (void) G_GNUC_CONST; -MediaArtProcess *media_art_process_new (GError **error); -gboolean media_art_process_uri (MediaArtProcess *process, - MediaArtType type, - MediaArtProcessFlags flags, - const gchar *uri, - const gchar *artist, - const gchar *title, - GError **error); -gboolean media_art_process_file (MediaArtProcess *process, - MediaArtType type, - MediaArtProcessFlags flags, - GFile *file, - const gchar *artist, - const gchar *title, - GError **error); -gboolean media_art_process_buffer (MediaArtProcess *process, - MediaArtType type, - MediaArtProcessFlags flags, - GFile *related_file, - const guchar *buffer, - gsize len, - const gchar *mime, - const gchar *artist, - const gchar *title, - GError **error); +GType media_art_process_get_type (void) G_GNUC_CONST; + +MediaArtProcess *media_art_process_new (GError **error); +gboolean media_art_process_uri (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + const gchar *uri, + const gchar *artist, + const gchar *title, + GCancellable *cancellable, + GError **error); +void media_art_process_uri_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + const gchar *uri, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean media_art_process_uri_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error); +gboolean media_art_process_file (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *file, + const gchar *artist, + const gchar *title, + GCancellable *cancellable, + GError **error); +void media_art_process_file_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *file, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean media_art_process_file_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error); +gboolean media_art_process_buffer (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *related_file, + const guchar *buffer, + gsize len, + const gchar *mime, + const gchar *artist, + const gchar *title, + GCancellable *cancellable, + GError **error); +void media_art_process_buffer_async (MediaArtProcess *process, + MediaArtType type, + MediaArtProcessFlags flags, + GFile *related_file, + const guchar *buffer, + gsize len, + const gchar *mime, + const gchar *artist, + const gchar *title, + gint io_priority, + GCancellable *cancellable, + GAsyncReadyCallback callback, + gpointer user_data); +gboolean media_art_process_buffer_finish (MediaArtProcess *process, + GAsyncResult *result, + GError **error); G_END_DECLS diff --git a/tests/mediaarttest.c b/tests/mediaarttest.c index 22694b6..f93845c 100644 --- a/tests/mediaarttest.c +++ b/tests/mediaarttest.c @@ -36,23 +36,23 @@ typedef struct { static TestInfo strip_test_cases [] = { { "nothing-to-strip", "nothing to strip here", NULL, "nothing to strip here" }, - { "case-strip", "Upper Case gOEs dOwN", NULL, "upper case goes down" }, + { "case-strip", "Upper Case gOEs dOwN", NULL, "upper case goes down" }, { "single-char", "o", NULL, "o" }, - { "single-char-case", "A", NULL, "a" }, - { "remove-parenthesis-round", "cool album (CD1)", NULL, "cool album" }, + { "single-char-case", "A", NULL, "a" }, + { "remove-parenthesis-round", "cool album (CD1)", NULL, "cool album" }, { "remove-parenthesis-square", "cool album [CD1]", NULL, "cool album" }, - { "remove-parenthesis-squirly", "cool album {CD1}", NULL, "cool album" }, - { "remove-parenthesis-gt-lt", "cool album ", NULL, "cool album" }, - { "whitespace", " ", NULL, "" }, - { "whitespace-with-content", " a ", NULL, "a" }, - { "messy-title", "messy #title & stuff?", NULL, "messy title stuff" }, + { "remove-parenthesis-squirly", "cool album {CD1}", NULL, "cool album" }, + { "remove-parenthesis-gt-lt", "cool album ", NULL, "cool album" }, + { "whitespace", " ", NULL, "" }, + { "whitespace-with-content", " a ", NULL, "a" }, + { "messy-title", "messy #title & stuff?", NULL, "messy title stuff" }, { "unbalanced-brackets-square-start", "Unbalanced [brackets", NULL, "unbalanced brackets" }, - { "unbalanced-brackets-round-start", "Unbalanced (brackets", NULL, "unbalanced brackets" }, - { "unbalanced-brackets-gt-lt-start", "Unbalanced ", NULL, "unbalanced brackets" }, - { "messy-title-punctuation", "Live at *WEMBLEY* dude!", NULL, "live at wembley dude" }, + { "unbalanced-brackets-round-start", "Unbalanced (brackets", NULL, "unbalanced brackets" }, + { "unbalanced-brackets-gt-lt-start", "Unbalanced ", NULL, "unbalanced brackets" }, + { "messy-title-punctuation", "Live at *WEMBLEY* dude!", NULL, "live at wembley dude" }, { "crap-brackets-everywhere", "met[xX[x]alli]ca", NULL, "metallica" }, { NULL, NULL, NULL, NULL } }; @@ -60,20 +60,20 @@ static TestInfo strip_test_cases [] = { static TestInfo location_test_cases [] = { { "normal-case", "Beatles", "Sgt. Pepper", - "album-2a9ea35253dbec60e76166ec8420fbda-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, + "album-2a9ea35253dbec60e76166ec8420fbda-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, { "empty-artist", "", "sgt. pepper", - "album-d41d8cd98f00b204e9800998ecf8427e-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, + "album-d41d8cd98f00b204e9800998ecf8427e-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, { "whitespace-artist", " ", "sgt. pepper", - "album-d41d8cd98f00b204e9800998ecf8427e-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, + "album-d41d8cd98f00b204e9800998ecf8427e-cfba4326a32b44b8760b3a2fc827a634.jpeg" }, { "null-artist", NULL, "sgt. pepper", - "album-cfba4326a32b44b8760b3a2fc827a634-7215ee9c7d9dc229d2921a40e899ec5f.jpeg" }, + "album-cfba4326a32b44b8760b3a2fc827a634-7215ee9c7d9dc229d2921a40e899ec5f.jpeg" }, { "null-title", "Beatles", NULL, - "album-2a9ea35253dbec60e76166ec8420fbda-7215ee9c7d9dc229d2921a40e899ec5f.jpeg" }, - { NULL, NULL, NULL, NULL } + "album-2a9ea35253dbec60e76166ec8420fbda-7215ee9c7d9dc229d2921a40e899ec5f.jpeg" }, + { NULL, NULL, NULL, NULL } }; static void @@ -92,30 +92,15 @@ teardown (TestInfo *info, { } -static void -test_mediaart_new (TestInfo *test_info, - gconstpointer context) -{ - MediaArtProcess *process; - GError *error = NULL; - - /* Test: creation of object */ - process = media_art_process_new (&error); - g_assert_no_error (error); - g_assert (process != NULL); - - g_object_unref (process); -} - static void test_mediaart_stripping (TestInfo *test_info, gconstpointer context) { - gchar *result; + gchar *result; - result = media_art_strip_invalid_entities (test_info->input1); - g_assert_cmpstr (result, ==, test_info->expected); - g_free (result); + result = media_art_strip_invalid_entities (test_info->input1); + g_assert_cmpstr (result, ==, test_info->expected); + g_free (result); } static void @@ -132,9 +117,9 @@ test_mediaart_stripping_failures (void) /* a. Return NULL for NULL (subprocess) * b. Return NULL for "" */ - stripped = media_art_strip_invalid_entities (""); - g_assert (stripped); - g_assert_cmpstr (stripped, ==, ""); + stripped = media_art_strip_invalid_entities (""); + g_assert (stripped); + g_assert_cmpstr (stripped, ==, ""); g_test_trap_subprocess ("/mediaart/stripping_failures/subprocess", 0, 0); g_test_trap_assert_failed (); @@ -146,75 +131,151 @@ static void test_mediaart_location (TestInfo *test_info, gconstpointer context) { - gchar *path = NULL, *local_uri = NULL; - gchar *expected; - - media_art_get_path (test_info->input1, - test_info->input2, - "album", - "file:///home/test/a.mp3", - &path, - &local_uri); - expected = g_build_path (G_DIR_SEPARATOR_S, - g_get_user_cache_dir (), - "media-art", - test_info->expected, - NULL); - g_assert_cmpstr (path, ==, expected); - - g_free (expected); - g_free (path); - g_free (local_uri); + gchar *path = NULL, *local_uri = NULL; + gchar *expected; + + media_art_get_path (test_info->input1, + test_info->input2, + "album", + "file:///home/test/a.mp3", + &path, + &local_uri); + expected = g_build_path (G_DIR_SEPARATOR_S, + g_get_user_cache_dir (), + "media-art", + test_info->expected, + NULL); + g_assert_cmpstr (path, ==, expected); + + g_free (expected); + g_free (path); + g_free (local_uri); } static void test_mediaart_location_null (void) { - gchar *path = NULL, *local_uri = NULL; + gchar *path = NULL, *local_uri = NULL; - /* NULL parameters */ - media_art_get_path (NULL, "some-title", "album", "file:///a/b/c.mp3", &path, &local_uri); - g_assert (path != NULL); - g_assert (local_uri != NULL); + /* NULL parameters */ + media_art_get_path (NULL, "some-title", "album", "file:///a/b/c.mp3", &path, &local_uri); + g_assert (path != NULL); + g_assert (local_uri != NULL); - media_art_get_path ("some-artist", NULL, "album", "file:///a/b/c.mp3", &path, &local_uri); - g_assert (path != NULL); - g_assert (local_uri != NULL); + media_art_get_path ("some-artist", NULL, "album", "file:///a/b/c.mp3", &path, &local_uri); + g_assert (path != NULL); + g_assert (local_uri != NULL); } static void test_mediaart_location_path (void) { - gchar *path = NULL, *local_uri = NULL; - gchar *expected; - - /* Use path instead of URI */ - media_art_get_path (location_test_cases[0].input1, - location_test_cases[0].input2, - "album", - "/home/test/a.mp3", - &path, - &local_uri); - expected = g_build_path (G_DIR_SEPARATOR_S, - g_get_user_cache_dir (), - "media-art", - location_test_cases[0].expected, - NULL); - g_assert_cmpstr (path, ==, expected); - - g_free (expected); - g_free (path); - g_free (local_uri); + gchar *path = NULL, *local_uri = NULL; + gchar *expected; + + /* Use path instead of URI */ + media_art_get_path (location_test_cases[0].input1, + location_test_cases[0].input2, + "album", + "/home/test/a.mp3", + &path, + &local_uri); + expected = g_build_path (G_DIR_SEPARATOR_S, + g_get_user_cache_dir (), + "media-art", + location_test_cases[0].expected, + NULL); + g_assert_cmpstr (path, ==, expected); + + g_free (expected); + g_free (path); + g_free (local_uri); +} + +static void +test_mediaart_process_new (void) +{ + MediaArtProcess *process; + GError *error = NULL; + gchar *dir; + + dir = g_build_filename (g_get_user_cache_dir (), "media-art", NULL); + g_assert_false (g_file_test (dir, G_FILE_TEST_EXISTS)); + + /* Creates media-art cache dir if it doesn't exist ... */ + process = media_art_process_new (&error); + g_assert_no_error (error); + + g_assert_true (g_file_test (dir, G_FILE_TEST_EXISTS)); + + g_free (dir); + + g_object_unref (process); +} + +static void +test_mediaart_remove_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GError *error = NULL; + GMainLoop *ml = user_data; + gboolean success; + + success = media_art_remove_finish (source_object, result, &error); + g_assert_no_error (error); + g_assert_true (success); + + g_main_loop_quit (ml); +} + +static void +test_mediaart_remove (const gchar *artist, + const gchar *title, + gpointer user_data) +{ + GCancellable *cancellable; + + cancellable = g_cancellable_new (); + + /* Remove album art */ + media_art_remove_async (artist, + title, + G_PRIORITY_DEFAULT, + NULL, + cancellable, + test_mediaart_remove_cb, + user_data); + + g_object_unref (cancellable); +} + +static void +test_mediaart_process_file_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + MediaArtProcess *process = MEDIA_ART_PROCESS (source_object); + GError *error = NULL; + GMainLoop *ml = user_data; + gboolean success; + + success = media_art_process_file_finish (process, result, &error); + g_assert_no_error (error); + g_assert_true (success); + + test_mediaart_remove ("King Kilo", "Radium", ml); } static void -test_mediaart_embedded_mp3 (void) +test_mediaart_process_file (void) { MediaArtProcess *process; + GMainLoop *ml; + GCancellable *cancellable; GError *error = NULL; GFile *file = NULL; gchar *path; - gboolean retval; path = g_build_filename (G_DIR_SEPARATOR_S, TOP_SRCDIR, "tests", "543249_King-Kilo---Radium.mp3", NULL); file = g_file_new_for_path (path); @@ -223,135 +284,166 @@ test_mediaart_embedded_mp3 (void) process = media_art_process_new (&error); g_assert_no_error (error); - retval = media_art_process_file (process, - MEDIA_ART_ALBUM, - MEDIA_ART_PROCESS_FLAGS_FORCE, - file, - "King Kilo", /* artist */ - "Radium", /* title */ - &error); + ml = g_main_loop_new (NULL, FALSE); + cancellable = g_cancellable_new (); - g_assert_no_error (error); - g_assert_true (retval); + media_art_process_file_async (process, + MEDIA_ART_ALBUM, + MEDIA_ART_PROCESS_FLAGS_FORCE, + file, + "King Kilo", /* artist */ + "Radium", /* title */ + G_PRIORITY_DEFAULT, + cancellable, + test_mediaart_process_file_cb, + ml); - g_object_unref (file); + g_main_loop_run (ml); + g_main_loop_unref (ml); + g_object_unref (cancellable); g_object_unref (process); } static void -test_mediaart_remove_cb (GObject *source_object, - GAsyncResult *result, - gpointer user_data) +test_mediaart_process_buffer_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) { GError *error = NULL; - GFile *file = user_data; + GFile *file; + gchar *path; + gchar *expected; + gchar *out_path = NULL; + gchar *out_uri = NULL; gboolean success; - success = media_art_remove_finish (source_object, result, &error); - g_assert_no_error (error); - g_assert_true (success); + success = media_art_process_buffer_finish (MEDIA_ART_PROCESS (source_object), result, &error); + g_assert_no_error (error); + g_assert_true (success); - success = media_art_remove ("Lanedo", NULL, NULL, &error); - g_assert_no_error (error); - g_assert_true (success); + /* Check cache exists */ + path = g_build_filename (G_DIR_SEPARATOR_S, TOP_SRCDIR, "tests", "cover.png", NULL); + file = g_file_new_for_path (path); - g_object_unref (file); + media_art_get_path ("Lanedo", /* artist / title */ + NULL, /* album */ + NULL, /* prefix */ + path, + &out_path, + &out_uri); + g_free (path); + g_object_unref (file); + + expected = g_build_path (G_DIR_SEPARATOR_S, + g_get_user_cache_dir (), + "media-art", + "album-be60c84852d9762b0a896ba9ba24245e-7215ee9c7d9dc229d2921a40e899ec5f.jpeg", + NULL); + g_assert_cmpstr (out_path, ==, expected); + /* FIXME: Why is out_uri NULL? */ + /* FIXME: Why does this next test fail - i.e. file does not + * exist if we've processed it? + */ + g_assert (g_file_test (out_path, G_FILE_TEST_EXISTS) == TRUE); + + test_mediaart_remove ("Lanedo", NULL, user_data); + + g_free (out_path); + g_free (out_uri); + g_free (expected); } static void test_mediaart_process_buffer (void) { MediaArtProcess *process; - GCancellable *cancellable; + GMainLoop *ml; + GCancellable *cancellable; + GFile *file; GError *error = NULL; - GFile *file = NULL; - gchar *dir; gchar *path; gchar *out_path = NULL; gchar *out_uri = NULL; - gchar *expected; - gboolean retval; + unsigned char *buffer = NULL; + size_t length = 0; + const gchar *mime; + + cancellable = g_cancellable_new (); path = g_build_filename (G_DIR_SEPARATOR_S, TOP_SRCDIR, "tests", "cover.png", NULL); - file = g_file_new_for_path (path); /* Check data is not cached currently */ media_art_get_path ("Lanedo", /* artist / title */ NULL, /* album */ NULL, /* prefix */ - path, - &out_path, - &out_uri); + path, + &out_path, + &out_uri); g_assert_false (g_file_test (out_path, G_FILE_TEST_EXISTS)); g_free (out_path); g_free (out_uri); - /* Creates media-art cache dir if it doesn't exist ... */ process = media_art_process_new (&error); g_assert_no_error (error); + g_assert_nonnull (process); - dir = g_build_filename (g_get_user_cache_dir (), "media-art", NULL); - g_assert_true (g_file_test (dir, G_FILE_TEST_EXISTS)); - g_free (dir); + ml = g_main_loop_new (NULL, FALSE); /* Process data */ - retval = media_art_process_file (process, - MEDIA_ART_ALBUM, - MEDIA_ART_PROCESS_FLAGS_NONE, - file, - NULL, /* album */ - "Lanedo", /* title */ - &error); + mime = "image/png"; + g_file_get_contents (path, (gchar**) &buffer, &length, &error); g_assert_no_error (error); - g_assert_true (retval); - /* Check cache exists */ - media_art_get_path ("Lanedo", /* artist / title */ - NULL, /* album */ - NULL, /* prefix */ - path, - &out_path, - &out_uri); - - expected = g_build_path (G_DIR_SEPARATOR_S, - g_get_user_cache_dir (), - "media-art", - "album-be60c84852d9762b0a896ba9ba24245e-7215ee9c7d9dc229d2921a40e899ec5f.jpeg", - NULL); - g_assert_cmpstr (out_path, ==, expected); - /* FIXME: Why is out_uri NULL? */ - /* FIXME: Why does this next test fail - i.e. file does not - * exist if we've processed it? - */ - g_assert (g_file_test (out_path, G_FILE_TEST_EXISTS) == TRUE); - - g_free (out_path); - g_free (out_uri); - g_free (expected); - - /* Remove album art */ - cancellable = g_cancellable_new (); - media_art_remove_async ("Lanedo", - "", - G_PRIORITY_DEFAULT, - G_OBJECT (process), - cancellable, - test_mediaart_remove_cb, - file); - - g_object_unref (cancellable); - g_free (path); + file = g_file_new_for_path (path); + g_free (path); + + media_art_process_buffer_async (process, + MEDIA_ART_ALBUM, + MEDIA_ART_PROCESS_FLAGS_NONE, + file, + buffer, + length, + mime, + NULL, /* album */ + "Lanedo", /* title */ + G_PRIORITY_DEFAULT, + cancellable, + test_mediaart_process_buffer_cb, + ml); + + g_main_loop_run (ml); + g_main_loop_unref (ml); + + g_object_unref (file); + g_object_unref (cancellable); g_object_unref (process); } +static void +test_mediaart_process_uri_cb (GObject *source_object, + GAsyncResult *result, + gpointer user_data) +{ + GError *error = NULL; + gboolean success; + + success = media_art_process_uri_finish (MEDIA_ART_PROCESS (source_object), result, &error); + g_assert_false (success); + g_assert_error (error, g_io_error_quark(), G_IO_ERROR_NOT_FOUND); + g_clear_error (&error); +} + static void test_mediaart_process_failures (void) { MediaArtProcess *process; GError *error = NULL; + GCancellable *cancellable; + + cancellable = g_cancellable_new (); - g_test_trap_subprocess ("/mediaart/process_failures/subprocess", 0, 0 /*G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR*/); + g_test_trap_subprocess ("/mediaart/process/failures/subprocess", 0, 0 /*G_TEST_SUBPROCESS_INHERIT_STDOUT | G_TEST_SUBPROCESS_INHERIT_STDERR*/); g_test_trap_assert_failed (); g_test_trap_assert_stderr ("*assertion 'uri != NULL' failed*"); @@ -359,16 +451,16 @@ test_mediaart_process_failures (void) g_assert_no_error (error); /* Test: invalid file */ - g_assert (!media_art_process_uri (process, - MEDIA_ART_ALBUM, - MEDIA_ART_PROCESS_FLAGS_NONE, - "file:///invalid/path.png", - "Foo", /* album */ - "Bar", /* title */ - &error)); - - g_assert_error (error, g_io_error_quark(), G_IO_ERROR_NOT_FOUND); - g_clear_error (&error); + media_art_process_uri_async (process, + MEDIA_ART_ALBUM, + MEDIA_ART_PROCESS_FLAGS_NONE, + "file:///invalid/path.png", + "Foo", /* album */ + "Bar", /* title */ + G_PRIORITY_DEFAULT, + cancellable, + test_mediaart_process_uri_cb, + NULL); /* Test: Invalid mime type */ /* g_assert (!media_art_process_uri (process, */ @@ -379,6 +471,7 @@ test_mediaart_process_failures (void) /* MEDIA_ART_ALBUM, */ /* "Foo", /\* album *\/ */ /* "Bar", /\* title *\/ */ + /* NULL, */ /* &error)); */ /* g_message ("code:%d, domain:%d, error:'%s'\n", error->code, error->domain, error->message); */ @@ -401,6 +494,7 @@ test_mediaart_process_failures_subprocess (void) NULL, "Foo", /* album */ "Bar", /* title */ + NULL, &error)); g_assert_no_error (error); @@ -412,18 +506,16 @@ main (int argc, char **argv) { const gchar *cache_home_originally; const gchar *test_dir; - gchar *dir; + gchar *dir; gint success; gint i; - g_test_init (&argc, &argv, NULL); + g_test_init (&argc, &argv, NULL); test_dir = g_test_get_dir (G_TEST_BUILT); cache_home_originally = g_getenv ("XDG_CACHE_HOME"); g_setenv ("XDG_CACHE_HOME", test_dir, TRUE); - g_test_add ("/mediaart/new", TestInfo, NULL, setup, test_mediaart_new, teardown); - for (i = 0; strip_test_cases[i].test_name; i++) { gchar *testpath; @@ -432,8 +524,8 @@ main (int argc, char **argv) g_free (testpath); } - g_test_add_func ("/mediaart/stripping_failures", test_mediaart_stripping_failures); - g_test_add_func ("/mediaart/stripping_failures/subprocess", test_mediaart_stripping_failures_subprocess); + g_test_add_func ("/mediaart/stripping_failures", test_mediaart_stripping_failures); + g_test_add_func ("/mediaart/stripping_failures/subprocess", test_mediaart_stripping_failures_subprocess); for (i = 0; location_test_cases[i].test_name; i++) { gchar *testpath; @@ -443,25 +535,26 @@ main (int argc, char **argv) g_free (testpath); } - g_test_add_func ("/mediaart/location_null", test_mediaart_location_null); - g_test_add_func ("/mediaart/location_path", test_mediaart_location_path); - g_test_add_func ("/mediaart/embedded_mp3", test_mediaart_embedded_mp3); - g_test_add_func ("/mediaart/process_buffer", test_mediaart_process_buffer); - g_test_add_func ("/mediaart/process_failures", test_mediaart_process_failures); - g_test_add_func ("/mediaart/process_failures/subprocess", test_mediaart_process_failures_subprocess); + g_test_add_func ("/mediaart/location_null", test_mediaart_location_null); + g_test_add_func ("/mediaart/location_path", test_mediaart_location_path); + g_test_add_func ("/mediaart/process/new", test_mediaart_process_new); + g_test_add_func ("/mediaart/process/file", test_mediaart_process_file); + g_test_add_func ("/mediaart/process/buffer", test_mediaart_process_buffer); + g_test_add_func ("/mediaart/process/failures", test_mediaart_process_failures); + g_test_add_func ("/mediaart/process/failures/subprocess", test_mediaart_process_failures_subprocess); - success = g_test_run (); + success = g_test_run (); - /* Clean up */ + /* Clean up */ dir = g_build_filename (g_get_user_cache_dir (), "media-art", NULL); g_rmdir (dir); g_free (dir); - if (cache_home_originally) { - g_setenv ("XDG_CACHE_HOME", cache_home_originally, TRUE); - } else { - g_unsetenv ("XDG_CACHE_HOME"); - } + if (cache_home_originally) { + g_setenv ("XDG_CACHE_HOME", cache_home_originally, TRUE); + } else { + g_unsetenv ("XDG_CACHE_HOME"); + } - return success; + return success; } -- cgit v1.2.1