From e71691bae890040b83cfd54a2d9a1097d5026866 Mon Sep 17 00:00:00 2001 From: John Mark Bell Date: Fri, 6 May 2011 20:40:09 +0000 Subject: Merge branches/jmb/content-factory to trunk svn path=/trunk/netsurf/; revision=12283 --- image/mng.c | 430 ++++++++++++++++++++++++++++++++++++++++++++---------------- 1 file changed, 316 insertions(+), 114 deletions(-) (limited to 'image/mng.c') diff --git a/image/mng.c b/image/mng.c index 6067aa8e8..a6b0377c4 100644 --- a/image/mng.c +++ b/image/mng.c @@ -23,9 +23,6 @@ #include "utils/config.h" #ifdef WITH_MNG -/* This must come first due to libpng issues */ -#include "content/content_protected.h" - #include #include #include @@ -33,6 +30,7 @@ #include #include #include +#include "content/content_protected.h" #include "desktop/options.h" #include "desktop/plotters.h" #include "image/bitmap.h" @@ -40,12 +38,44 @@ #include "utils/log.h" #include "utils/messages.h" #include "utils/schedule.h" +#include "utils/talloc.h" #include "utils/utils.h" /* We do not currently support any form of colour/gamma correction, nor do we support dynamic MNGs. */ +typedef struct nsmng_content +{ + struct content base; + + bool opaque_test_pending; + bool read_start; + bool read_resume; + int read_size; + bool waiting; + bool displayed; + void *handle; +} nsmng_content; + +static nserror nsmng_create(const content_handler *handler, + lwc_string *imime_type, const struct http_parameter *params, + llcache_handle *llcache, const char *fallback_charset, + bool quirks, struct content **c); +static nserror nsmng_create_mng_data(nsmng_content *c); +static bool nsmng_process_data(struct content *c, const char *data, + unsigned int size); +static bool nsmng_convert(struct content *c); +static void nsmng_destroy(struct content *c); +static bool nsmng_redraw(struct content *c, int x, int y, + int width, int height, const struct rect *clip, + float scale, colour background_colour); +static bool nsmng_redraw_tiled(struct content *c, int x, int y, + int width, int height, const struct rect *clip, + float scale, colour background_colour, + bool repeat_x, bool repeat_y); +static nserror nsmng_clone(const struct content *old, struct content **newc); +static content_type nsmng_content_type(lwc_string *mime_type); static mng_bool nsmng_openstream(mng_handle mng); static mng_bool nsmng_readdata(mng_handle mng, mng_ptr buffer, @@ -59,7 +89,7 @@ static mng_bool nsmng_refresh(mng_handle mng, mng_uint32 x, mng_uint32 y, mng_uint32 w, mng_uint32 h); static mng_bool nsmng_settimer(mng_handle mng, mng_uint32 msecs); static void nsmng_animate(void *p); -static bool nsmng_broadcast_error(struct content *c, mng_retcode code); +static nserror nsmng_broadcast_error(nsmng_content *c, mng_retcode code); static mng_bool nsmng_errorproc(mng_handle mng, mng_int32 code, mng_int8 severity, mng_chunkid chunktype, mng_uint32 chunkseq, mng_int32 extra1, mng_int32 extra2, mng_pchar text); @@ -68,8 +98,131 @@ static mng_ptr nsmng_alloc(mng_size_t n); static void nsmng_free(mng_ptr p, mng_size_t n); #endif +static const content_handler nsmng_content_handler = { + nsmng_create, + nsmng_process_data, + nsmng_convert, + NULL, + nsmng_destroy, + NULL, + NULL, + NULL, + nsmng_redraw, + nsmng_redraw_tiled, + NULL, + NULL, + nsmng_clone, + NULL, + nsmng_content_type, + false +}; + +static const char *jng_types[] = { + "image/jng", + "image/x-jng" +}; + +static const char *mng_types[] = { + "image/mng", + "image/x-mng", + "video/mng", + "video/x-mng" +}; + +static const char *png_types[] = { + "image/png" +}; + +static lwc_string *jng_mime_types[NOF_ELEMENTS(jng_types)]; +static lwc_string *mng_mime_types[NOF_ELEMENTS(mng_types)]; +static lwc_string *png_mime_types[NOF_ELEMENTS(png_types)]; + +nserror nsmng_init(void) +{ + uint32_t i; + lwc_error lerror; + nserror error; + +#define register_types(type) \ + for (i = 0; i < NOF_ELEMENTS(type##_mime_types); i++) { \ + lerror = lwc_intern_string(type##_types[i], \ + strlen(type##_types[i]), \ + &type##_mime_types[i]); \ + if (lerror != lwc_error_ok) { \ + error = NSERROR_NOMEM; \ + goto error; \ + } \ + \ + error = content_factory_register_handler( \ + type##_mime_types[i], \ + &nsmng_content_handler); \ + if (error != NSERROR_OK) \ + goto error; \ + } + + register_types(jng) + register_types(mng) + register_types(png) + + return NSERROR_OK; + +error: + nsmng_fini(); + + return error; +} + +void nsmng_fini(void) +{ + uint32_t i; + + for (i = 0; i < NOF_ELEMENTS(jng_mime_types); i++) { + if (jng_mime_types[i] != NULL) + lwc_string_unref(jng_mime_types[i]); + } + + for (i = 0; i < NOF_ELEMENTS(mng_mime_types); i++) { + if (mng_mime_types[i] != NULL) + lwc_string_unref(mng_mime_types[i]); + } + + for (i = 0; i < NOF_ELEMENTS(png_mime_types); i++) { + if (png_mime_types[i] != NULL) + lwc_string_unref(png_mime_types[i]); + } +} + +nserror nsmng_create(const content_handler *handler, + lwc_string *imime_type, const struct http_parameter *params, + llcache_handle *llcache, const char *fallback_charset, + bool quirks, struct content **c) +{ + nsmng_content *mng; + nserror error; + + mng = talloc_zero(0, nsmng_content); + if (mng == NULL) + return NSERROR_NOMEM; + + error = content__init(&mng->base, handler, imime_type, params, + llcache, fallback_charset, quirks); + if (error != NSERROR_OK) { + talloc_free(mng); + return error; + } + + error = nsmng_create_mng_data(mng); + if (error != NSERROR_OK) { + talloc_free(mng); + return error; + } + + *c = (struct content *) mng; -bool nsmng_create(struct content *c, const struct http_parameter *params) + return NSERROR_OK; +} + +nserror nsmng_create_mng_data(nsmng_content *c) { mng_retcode code; union content_msg_data msg_data; @@ -79,20 +232,20 @@ bool nsmng_create(struct content *c, const struct http_parameter *params) /* Initialise the library */ #ifdef MNG_INTERNAL_MEMMNGMT - c->data.mng.handle = mng_initialize(c, MNG_NULL, MNG_NULL, MNG_NULL); + c->handle = mng_initialize(c, MNG_NULL, MNG_NULL, MNG_NULL); #else - c->data.mng.handle = mng_initialize(c, nsmng_alloc, nsmng_free, MNG_NULL); + c->handle = mng_initialize(c, nsmng_alloc, nsmng_free, MNG_NULL); #endif - if (c->data.mng.handle == MNG_NULL) { + if (c->handle == MNG_NULL) { LOG(("Unable to initialise MNG library.")); msg_data.error = messages_get("NoMemory"); - content_broadcast(c, CONTENT_MSG_ERROR, msg_data); - return false; + content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); + return NSERROR_NOMEM; } /* We need to decode in suspension mode */ - code = mng_set_suspensionmode(c->data.mng.handle, MNG_TRUE); + code = mng_set_suspensionmode(c->handle, MNG_TRUE); if (code) { LOG(("Unable to set suspension mode.")); return nsmng_broadcast_error(c, code); @@ -100,22 +253,22 @@ bool nsmng_create(struct content *c, const struct http_parameter *params) /* We need to register our callbacks */ - code = mng_setcb_openstream(c->data.mng.handle, nsmng_openstream); + code = mng_setcb_openstream(c->handle, nsmng_openstream); if (code) { LOG(("Unable to set openstream callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_readdata(c->data.mng.handle, nsmng_readdata); + code = mng_setcb_readdata(c->handle, nsmng_readdata); if (code) { LOG(("Unable to set readdata callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_closestream(c->data.mng.handle, nsmng_closestream); + code = mng_setcb_closestream(c->handle, nsmng_closestream); if (code) { LOG(("Unable to set closestream callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_processheader(c->data.mng.handle, nsmng_processheader); + code = mng_setcb_processheader(c->handle, nsmng_processheader); if (code) { LOG(("Unable to set processheader callback.")); return nsmng_broadcast_error(c, code); @@ -123,29 +276,29 @@ bool nsmng_create(struct content *c, const struct http_parameter *params) /* Register our callbacks for displaying */ - code = mng_setcb_getcanvasline(c->data.mng.handle, nsmng_getcanvasline); + code = mng_setcb_getcanvasline(c->handle, nsmng_getcanvasline); if (code) { LOG(("Unable to set getcanvasline callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_refresh(c->data.mng.handle, nsmng_refresh); + code = mng_setcb_refresh(c->handle, nsmng_refresh); if (code) { LOG(("Unable to set refresh callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_gettickcount(c->data.mng.handle, nsmng_gettickcount); + code = mng_setcb_gettickcount(c->handle, nsmng_gettickcount); if (code) { LOG(("Unable to set gettickcount callback.")); return nsmng_broadcast_error(c, code); } - code = mng_setcb_settimer(c->data.mng.handle, nsmng_settimer); + code = mng_setcb_settimer(c->handle, nsmng_settimer); if (code) { LOG(("Unable to set settimer callback.")); return nsmng_broadcast_error(c, code); } /* register error handling function */ - code = mng_setcb_errorproc(c->data.mng.handle, nsmng_errorproc); + code = mng_setcb_errorproc(c->handle, nsmng_errorproc); if (code) { LOG(("Unable to set errorproc")); return nsmng_broadcast_error(c, code); @@ -153,13 +306,14 @@ bool nsmng_create(struct content *c, const struct http_parameter *params) /* Initialise the reading */ - c->data.mng.read_start = true; - c->data.mng.read_resume = false; - c->data.mng.read_size = 0; - c->data.mng.waiting = false; + c->read_start = true; + c->read_resume = false; + c->read_size = 0; + c->waiting = false; - c->data.mng.displayed = false; - return true; + c->displayed = false; + + return NSERROR_OK; } @@ -176,7 +330,7 @@ mng_bool nsmng_openstream(mng_handle mng) mng_bool nsmng_readdata(mng_handle mng, mng_ptr buffer, mng_uint32 size, mng_uint32 *bytesread) { - struct content *c; + nsmng_content *c; const char *data; unsigned long data_size; @@ -186,19 +340,19 @@ mng_bool nsmng_readdata(mng_handle mng, mng_ptr buffer, mng_uint32 size, /* Get our content back */ - c = (struct content *) mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); /* Copy any data we have (maximum of 'size') */ - data = content__get_source_data(c, &data_size); + data = content__get_source_data(&c->base, &data_size); - *bytesread = ((data_size - c->data.mng.read_size) < size) ? - (data_size - c->data.mng.read_size) : size; + *bytesread = ((data_size - c->read_size) < size) ? + (data_size - c->read_size) : size; if ((*bytesread) > 0) { - memcpy(buffer, data + c->data.mng.read_size, *bytesread); - c->data.mng.read_size += *bytesread; + memcpy(buffer, data + c->read_size, *bytesread); + c->read_size += *bytesread; } /* Return success @@ -215,7 +369,7 @@ mng_bool nsmng_closestream(mng_handle mng) mng_bool nsmng_processheader(mng_handle mng, mng_uint32 width, mng_uint32 height) { - struct content *c; + nsmng_content *c; union content_msg_data msg_data; uint8_t *buffer; @@ -224,31 +378,31 @@ mng_bool nsmng_processheader(mng_handle mng, mng_uint32 width, /* This function is called when the header has been read and we know the dimensions of the canvas. */ - c = (struct content *)mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); - c->bitmap = bitmap_create(width, height, BITMAP_NEW); - if (!c->bitmap) { + c->base.bitmap = bitmap_create(width, height, BITMAP_NEW); + if (c->base.bitmap == NULL) { msg_data.error = messages_get("NoMemory"); - content_broadcast(c, CONTENT_MSG_ERROR, msg_data); + content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); LOG(("Insufficient memory to create canvas.")); return MNG_FALSE; } /* Get the buffer to ensure that it is allocated and the calls in * nsmng_getcanvasline() succeed. */ - buffer = bitmap_get_buffer(c->bitmap); - if (!buffer) { + buffer = bitmap_get_buffer(c->base.bitmap); + if (buffer == NULL) { msg_data.error = messages_get("NoMemory"); - content_broadcast(c, CONTENT_MSG_ERROR, msg_data); + content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); LOG(("Insufficient memory to create canvas.")); return MNG_FALSE; } /* Initialise the content size */ - c->width = width; - c->height = height; + c->base.width = width; + c->base.height = height; /* Set the canvas style */ @@ -268,6 +422,7 @@ mng_bool nsmng_processheader(mng_handle mng, mng_uint32 width, bool nsmng_process_data(struct content *c, const char *data, unsigned int size) { + nsmng_content *mng = (nsmng_content *) c; mng_retcode status; assert(c != NULL); @@ -275,21 +430,21 @@ bool nsmng_process_data(struct content *c, const char *data, unsigned int size) /* We only need to do any processing if we're starting/resuming reading. */ - if ((!c->data.mng.read_resume) && (!c->data.mng.read_start)) + if ((!mng->read_resume) && (!mng->read_start)) return true; /* Try to start processing, or process some more data */ - if (c->data.mng.read_start) { - status = mng_read(c->data.mng.handle); - c->data.mng.read_start = false; + if (mng->read_start) { + status = mng_read(mng->handle); + mng->read_start = false; } else { - status = mng_read_resume(c->data.mng.handle); + status = mng_read_resume(mng->handle); } - c->data.mng.read_resume = (status == MNG_NEEDMOREDATA); + mng->read_resume = (status == MNG_NEEDMOREDATA); if ((status != MNG_NOERROR) && (status != MNG_NEEDMOREDATA)) { LOG(("Failed to start/continue reading (%i).", status)); - return nsmng_broadcast_error(c, status); + return nsmng_broadcast_error(mng, status) == NSERROR_OK; } /* Continue onwards @@ -300,9 +455,14 @@ bool nsmng_process_data(struct content *c, const char *data, unsigned int size) bool nsmng_convert(struct content *c) { + nsmng_content *mng = (nsmng_content *) c; mng_retcode status; const char *data; unsigned long size; + lwc_string *content_type; + bool match; + bool is_mng = false; + uint32_t i; char title[100]; assert(c != NULL); @@ -312,15 +472,26 @@ bool nsmng_convert(struct content *c) /* by this point, the png should have been parsed * and the bitmap created, so ensure that's the case */ - if (!c->bitmap) - return nsmng_broadcast_error(c, -1); + if (content__get_bitmap(c) == NULL) + return nsmng_broadcast_error(mng, -1) == NSERROR_OK; /* Set the title */ - if (c->type == CONTENT_MNG) { + content_type = content__get_mime_type(c); + + for (i = 0; i < NOF_ELEMENTS(mng_mime_types); i++) { + if (lwc_string_caseless_isequal(content_type, mng_mime_types[i], + &match) == lwc_error_ok && match) { + is_mng = true; + break; + } + } + + if (is_mng) { snprintf(title, sizeof(title), messages_get("MNGTitle"), c->width, c->height, size); - } else if (c->type == CONTENT_PNG) { + } else if (lwc_string_caseless_isequal(content_type, png_mime_types[0], + &match) == lwc_error_ok && match) { snprintf(title, sizeof(title), messages_get("PNGTitle"), c->width, c->height, size); } else { @@ -329,6 +500,8 @@ bool nsmng_convert(struct content *c) } content__set_title(c, title); + lwc_string_unref(content_type); + c->size += c->width * c->height * 4; content_set_ready(c); content_set_done(c); @@ -349,28 +522,27 @@ bool nsmng_convert(struct content *c) */ /* Start displaying */ - status = mng_display(c->data.mng.handle); + status = mng_display(mng->handle); if ((status != MNG_NOERROR) && (status != MNG_NEEDTIMERWAIT)) { LOG(("Unable to start display (%i)", status)); - return nsmng_broadcast_error(c, status); + return nsmng_broadcast_error(mng, status) == NSERROR_OK; } bitmap_modified(c->bitmap); /* Optimise the plotting of JNG/PNGs */ - c->data.mng.opaque_test_pending = (c->type == CONTENT_PNG) || - (c->type == CONTENT_JNG); - if (c->data.mng.opaque_test_pending) + mng->opaque_test_pending = (is_mng == false); + if (mng->opaque_test_pending) bitmap_set_opaque(c->bitmap, false); /* free associated memory except for mngs where it may be subsequently needed for * animation decoding. */ - if (c->type != CONTENT_MNG) { - mng_handle handle = c->data.mng.handle; + if (is_mng == false) { + mng_handle handle = mng->handle; mng_cleanup(&handle); - c->data.mng.handle = NULL; + mng->handle = NULL; } return true; @@ -383,19 +555,19 @@ bool nsmng_convert(struct content *c) mng_ptr nsmng_getcanvasline(mng_handle mng, mng_uint32 line) { - struct content *c; + nsmng_content *c; assert(mng != NULL); /* Get our content back */ - c = (struct content *)mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); /* Calculate the address */ - return bitmap_get_buffer(c->bitmap) + - bitmap_get_rowstride(c->bitmap) * line; + return bitmap_get_buffer(c->base.bitmap) + + bitmap_get_rowstride(c->base.bitmap) * line; } @@ -433,13 +605,13 @@ mng_bool nsmng_refresh(mng_handle mng, mng_uint32 x, mng_uint32 y, mng_uint32 w, mng_uint32 h) { union content_msg_data data; - struct content *c; + nsmng_content *c; assert(mng != NULL); /* Get our content back */ - c = (struct content *)mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); /* Set the minimum redraw area @@ -463,11 +635,11 @@ mng_bool nsmng_refresh(mng_handle mng, mng_uint32 x, mng_uint32 y, /* Set the object characteristics */ - data.redraw.object = c; + data.redraw.object = &c->base; data.redraw.object_x = 0; data.redraw.object_y = 0; - data.redraw.object_width = c->width; - data.redraw.object_height = c->height; + data.redraw.object_width = c->base.width; + data.redraw.object_height = c->base.height; /* Only attempt to force the redraw if we've been requested to * display the image in the first place (i.e. nsmng_redraw has @@ -475,21 +647,21 @@ mng_bool nsmng_refresh(mng_handle mng, mng_uint32 x, mng_uint32 y, * an image that shouldn't be shown (e.g. if the image is a fallback * for an object that can't be rendered) */ - if (c->data.mng.displayed) - content_broadcast(c, CONTENT_MSG_REDRAW, data); + if (c->displayed) + content_broadcast(&c->base, CONTENT_MSG_REDRAW, data); return MNG_TRUE; } mng_bool nsmng_settimer(mng_handle mng, mng_uint32 msecs) { - struct content *c; + nsmng_content *c; assert(mng != NULL); /* Get our content back */ - c = (struct content *)mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); /* Perform the scheduling @@ -505,18 +677,20 @@ mng_bool nsmng_settimer(mng_handle mng, mng_uint32 msecs) void nsmng_destroy(struct content *c) { + nsmng_content *mng = (nsmng_content *) c; assert (c != NULL); /* Cleanup the MNG structure and release the canvas memory */ schedule_remove(nsmng_animate, c); - if (c->type == CONTENT_MNG) { - mng_handle handle = c->data.mng.handle; + + if (mng->handle != NULL) { + mng_handle handle = mng->handle; mng_cleanup(&handle); - c->data.mng.handle = NULL; + mng->handle = NULL; } if (c->bitmap) @@ -528,14 +702,15 @@ bool nsmng_redraw(struct content *c, int x, int y, int width, int height, const struct rect *clip, float scale, colour background_colour) { + nsmng_content *mng = (nsmng_content *) c; bool ret; /* mark image as having been requested to display */ - c->data.mng.displayed = true; + mng->displayed = true; - if ((c->bitmap) && (c->data.mng.opaque_test_pending)) { + if ((c->bitmap) && (mng->opaque_test_pending)) { bitmap_set_opaque(c->bitmap, bitmap_test_opaque(c->bitmap)); - c->data.mng.opaque_test_pending = false; + mng->opaque_test_pending = false; } ret = plot.bitmap(x, y, width, height, @@ -543,7 +718,7 @@ bool nsmng_redraw(struct content *c, int x, int y, /* Check if we need to restart the animation */ - if ((c->data.mng.waiting) && (option_animate_images)) + if ((mng->waiting) && (option_animate_images)) nsmng_animate(c); return ret; @@ -555,15 +730,16 @@ bool nsmng_redraw_tiled(struct content *c, int x, int y, float scale, colour background_colour, bool repeat_x, bool repeat_y) { + nsmng_content *mng = (nsmng_content *) c; bool ret; bitmap_flags_t flags = BITMAPF_NONE; /* mark image as having been requested to display */ - c->data.mng.displayed = true; + mng->displayed = true; - if ((c->bitmap) && (c->data.mng.opaque_test_pending)) { + if ((c->bitmap) && (mng->opaque_test_pending)) { bitmap_set_opaque(c->bitmap, bitmap_test_opaque(c->bitmap)); - c->data.mng.opaque_test_pending = false; + mng->opaque_test_pending = false; } if (repeat_x) @@ -577,35 +753,61 @@ bool nsmng_redraw_tiled(struct content *c, int x, int y, /* Check if we need to restart the animation */ - if ((c->data.mng.waiting) && (option_animate_images)) + if ((mng->waiting) && (option_animate_images)) nsmng_animate(c); return ret; } -bool nsmng_clone(const struct content *old, struct content *new_content) +nserror nsmng_clone(const struct content *old, struct content **newc) { + nsmng_content *mng; + nserror error; const char *data; unsigned long size; + mng = talloc_zero(0, nsmng_content); + if (mng == NULL) + return NSERROR_NOMEM; + + error = content__clone(old, &mng->base); + if (error != NSERROR_OK) { + content_destroy(&mng->base); + return error; + } + /* Simply replay create/process/convert */ - if (nsmng_create(new_content, NULL) == false) - return false; + error = nsmng_create_mng_data(mng); + if (error != NSERROR_OK) { + content_destroy(&mng->base); + return error; + } - data = content__get_source_data(new_content, &size); + data = content__get_source_data(&mng->base, &size); if (size > 0) { - if (nsmng_process_data(new_content, data, size) == false) - return false; + if (nsmng_process_data(&mng->base, data, size) == false) { + content_destroy(&mng->base); + return NSERROR_CLONE_FAILED; + } } if (old->status == CONTENT_STATUS_READY || old->status == CONTENT_STATUS_DONE) { - if (nsmng_convert(new_content) == false) - return false; + if (nsmng_convert(&mng->base) == false) { + content_destroy(&mng->base); + return NSERROR_CLONE_FAILED; + } } - return true; + *newc = (struct content *) mng; + + return NSERROR_OK; +} + +content_type nsmng_content_type(lwc_string *mime_type) +{ + return CONTENT_IMAGE; } /** @@ -613,22 +815,22 @@ bool nsmng_clone(const struct content *old, struct content *new_content) */ void nsmng_animate(void *p) { - struct content *c; + nsmng_content *c; assert(p != NULL); - c = (struct content *)p; + c = (nsmng_content *) p; /* If we used the last animation we advance, if not we try again later */ - if (c->user_list->next == NULL) { - c->data.mng.waiting = true; + if (c->base.user_list->next == NULL) { + c->waiting = true; } else { - c->data.mng.waiting = false; - mng_display_resume(c->data.mng.handle); - c->data.mng.opaque_test_pending = true; - if (c->bitmap) - bitmap_modified(c->bitmap); + c->waiting = false; + mng_display_resume(c->handle); + c->opaque_test_pending = true; + if (c->base.bitmap) + bitmap_modified(c->base.bitmap); } } @@ -638,9 +840,9 @@ void nsmng_animate(void *p) * Broadcasts an error message and returns false * * \param c the content to broadcast for - * \return false + * \return Appropriate error */ -bool nsmng_broadcast_error(struct content *c, mng_retcode code) +nserror nsmng_broadcast_error(nsmng_content *c, mng_retcode code) { union content_msg_data msg_data; char error[100]; @@ -649,14 +851,14 @@ bool nsmng_broadcast_error(struct content *c, mng_retcode code) if (code == MNG_OUTOFMEMORY) { msg_data.error = messages_get("NoMemory"); - content_broadcast(c, CONTENT_MSG_ERROR, msg_data); - return false; + content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); + return NSERROR_NOMEM; } snprintf(error, sizeof error, messages_get("MNGError"), code); msg_data.error = error; - content_broadcast(c, CONTENT_MSG_ERROR, msg_data); - return false; + content_broadcast(&c->base, CONTENT_MSG_ERROR, msg_data); + return NSERROR_MNG_ERROR; } @@ -664,12 +866,12 @@ mng_bool nsmng_errorproc(mng_handle mng, mng_int32 code, mng_int8 severity, mng_chunkid chunktype, mng_uint32 chunkseq, mng_int32 extra1, mng_int32 extra2, mng_pchar text) { - struct content *c; + nsmng_content *c; char chunk[5]; assert(mng != NULL); - c = (struct content *)mng_get_userdata(mng); + c = (nsmng_content *) mng_get_userdata(mng); assert(c != NULL); chunk[0] = (char)((chunktype >> 24) & 0xFF); @@ -679,11 +881,11 @@ mng_bool nsmng_errorproc(mng_handle mng, mng_int32 code, chunk[4] = '\0'; LOG(("error playing '%s' chunk %s (%d):", - content__get_url(c), chunk, chunkseq)); + content__get_url(&c->base), chunk, chunkseq)); LOG(("code %d severity %d extra1 %d extra2 %d text:'%s'", code, severity, extra1, extra2, text)); - return (0); + return (0); } -- cgit v1.2.3