apps/display-demo/app_slideshow.c

Go to the documentation of this file.

#include <assert.h>
#include <board.h>
#include <interrupt.h>
#include <led.h>
#include <mainloop.h>
#include <string.h>
#include <timer.h>
#include <fs/tsfs.h>
#include <gfx/gfx.h>
#include <gfx/win.h>

#include "app_desktop.h"
#include "app_slideshow.h"
#include "file_loader.h"


extern struct tsfs myfs;


#define COLOR_BACKGROUND     GFX_COLOR(0, 0, 0)



#define SECONDS_PER_SLIDE    4

#define SECONDS_PER_PAUSE    16

#define TIMER_CLOCK_RATE     (0xffff / 4)



#define SLIDE_SIZE_X         320

#define SLIDE_SIZE_Y         240



#define SLIDE_PREFIX_PICS    "s_"

#define SLIDE_PREFIX_AVR     "avr"

#define SLIDE_PREFIX_UC3     "uc3"

#define SLIDE_PREFIX_XMEGA   "xmega"

#define SLIDE_PREFIX_DX      "dispxpl"


struct slide_context {
        struct workqueue_task *task;
        struct win_window     *left;
        struct win_window     *middle;
        struct win_window     *right;
        struct timer          timer;
        uint16_t              timer_delay;
        uint8_t               secs_to_go;
        bool                  busy;
        bool                  exit_now;
        char                  *file_prefix;
        uint8_t               file_index;
};

static struct slide_context *slide_context;

static void slide_get_next_file(bool increment)
{
        char filename[TSFS_FILENAME_LEN + 1];
        uint8_t file_index;
        uint8_t prefix_len;
        uint8_t nr_of_files;

        file_index = slide_context->file_index;
        prefix_len = strlen(slide_context->file_prefix);
        nr_of_files = tsfs_nr_files(&myfs);

        // Search for next file with matching filename prefix.
        do {
                if (increment) {
                        file_index++;
                } else {
                        file_index--;
                }

                // Handle out-of-bounds file indexes.
                if (file_index > nr_of_files) {
                        file_index -= nr_of_files;
                }
                if (file_index < 1) {
                        file_index += nr_of_files;
                }

                // Break out of the loop if no new file could be found.
                if (file_index == slide_context->file_index) {
                        break;
                }

                /* Get the filename associated with the file index for
                 * comparison with the current filename prefix.
                 */
                tsfs_get_filename(&myfs, file_index, (uint8_t *)filename);
        } while (strncmp(slide_context->file_prefix, filename, prefix_len) !=
                        0);

        slide_context->file_index = file_index;
}

static void slide_show_file(void)
{
        enum status_code result;
        uint8_t filename[TSFS_FILENAME_LEN + 1];

        tsfs_get_filename(&myfs, slide_context->file_index, filename);

        result = load_file_to_screen((char *)filename, 0, 0, SLIDE_SIZE_X,
                        SLIDE_SIZE_Y, slide_context->task);

        if (result == STATUS_OK) {
                slide_context->busy = true;
        } else {
                slide_context->secs_to_go = 1;
                timer_start(CONFIG_TIMER_ID, &slide_context->timer);
                timer_set_alarm(CONFIG_TIMER_ID, &slide_context->timer,
                                slide_context->timer_delay);
        }
}

static void slide_timer_callback(struct timer *timer)
{
        uint8_t secs_to_go;

        secs_to_go = slide_context->secs_to_go;

        // Start loading next slide on timeout, otherwise reset the alarm.
        if (--secs_to_go == 0) {
                secs_to_go = SECONDS_PER_SLIDE;
                slide_get_next_file(true);
                slide_show_file();
        } else {
                timer_set_alarm(CONFIG_TIMER_ID, timer,
                                slide_context->timer_delay);
        }
        slide_context->secs_to_go = secs_to_go;
}

static bool slide_window_handler(struct win_window *win,
                enum win_event_type type, void const *data)
{
        irqflags_t flags;

        if (type == WIN_EVENT_POINTER) {
                // The data parameter points to the POINTER event information.
                struct win_pointer_event const *event =
                                (struct win_pointer_event const *)data;

                // Wait for the pointer to be released.
                if (event->type == WIN_POINTER_RELEASE) {
                        /* The timer must be stopped before checking if
                         * the application is currently loading a slide.
                         */
                        flags = cpu_irq_save();
                        timer_stop(CONFIG_TIMER_ID, &slide_context->timer);
                        cpu_irq_restore(flags);

                        if (slide_context->busy) {
                                // Do nothing if a slide is currently loading.
                                return true;

                        } else if (win == slide_context->left) {
                                /* Start loading of previous slide, and set
                                 * the longer pause timeout for the autoloading.
                                 */
                                slide_context->secs_to_go = SECONDS_PER_PAUSE;
                                slide_get_next_file(false);
                                slide_show_file();

                        } else if (win == slide_context->middle) {
                                // Exit the application immediately.
                                win_destroy(slide_context->left);
                                win_destroy(slide_context->middle);
                                win_destroy(slide_context->right);
                                membag_free(slide_context);
                                app_desktop_restart();

                        } else if (win == slide_context->right) {
                                /* Start loading of next slide, and set the
                                 * regular timeout for the autoloading.
                                 */
                                slide_context->secs_to_go = SECONDS_PER_SLIDE;
                                slide_get_next_file(true);
                                slide_show_file();
                        }
                }
        }

        // Always accept all events
        return true;
}

static void slide_worker(struct workqueue_task *task)
{
        slide_context->busy = false;

        timer_start(CONFIG_TIMER_ID, &slide_context->timer);
        timer_set_alarm(CONFIG_TIMER_ID, &slide_context->timer,
                        slide_context->timer_delay);
}

static void slide_launch_helper(struct workqueue_task *task,
                char *file_prefix)
{
        struct win_attributes attr;
        struct win_window     *root_win = win_get_root();
        struct timer          *timer;
        gfx_coord_t           gfx_width = gfx_get_width();
        gfx_coord_t           gfx_height = gfx_get_height();
        timer_res_t           timer_res;
        uint32_t              timer_clk;

        assert(task);

        // Allocate memory for the application context.
        slide_context = membag_alloc(sizeof(struct slide_context));
        if (!slide_context) {
                goto exit_no_context;
        }

        // Clear the display.
#ifdef CONFIG_GFX_USE_CLIPPING
        gfx_set_clipping(0, 0, gfx_width, gfx_height);
#endif /* CONFIG_GFX_USE_CLIPPING */
        gfx_draw_filled_rect(0, 0, gfx_width, gfx_height, COLOR_BACKGROUND);

        // Initialize the timer with the configured resolution.
        timer = &slide_context->timer;
        timer_init(CONFIG_TIMER_ID, timer, slide_timer_callback);
        timer_res = timer_set_resolution(CONFIG_TIMER_ID, timer,
                        TIMER_CLOCK_RATE);
        timer_write_resolution(CONFIG_TIMER_ID, timer, timer_res);
        timer_clk = timer_get_resolution(CONFIG_TIMER_ID, timer, timer_res);

        // Timer clock should be slow enough to allow for detection of 1 second.
        assert(timer_clk <= 0xffff);

        // Initialize the application context and task.
        slide_context->timer_delay = timer_clk;
        slide_context->secs_to_go = SECONDS_PER_SLIDE;
        slide_context->file_prefix = file_prefix;
        slide_context->file_index = 0;
        slide_context->task = task;
        workqueue_task_set_work_func(task, slide_worker);

        /* Create windows for the left, middle and right sections of display.
         * The middle window is half the width of the display, while the two
         * others are a quarter of the width.
         * These will use a common window event handler.
         */
        attr.area.pos.x = 0;
        attr.area.pos.y = 0;
        attr.area.size.x = gfx_width / 4;
        attr.area.size.y = gfx_height;
        attr.background = NULL;
        attr.event_handler = slide_window_handler;
        slide_context->left = win_create(root_win, &attr);
        if (!slide_context->left) {
                goto exit_no_left_window;
        }
        attr.area.pos.x += attr.area.size.x;
        attr.area.size.x = gfx_width / 2;
        slide_context->middle = win_create(root_win, &attr);
        if (!slide_context->middle) {
                goto exit_no_middle_window;
        }

        attr.area.pos.x += attr.area.size.x;
        attr.area.size.x = gfx_width - attr.area.pos.x;
        slide_context->right = win_create(root_win, &attr);
        if (!slide_context->right) {
                goto exit_no_right_window;
        }

        // Show the windows to enable user input.
        win_show(slide_context->left);
        win_show(slide_context->middle);
        win_show(slide_context->right);

        // Find first slideshow file and start loading.
        slide_get_next_file(true);
        slide_show_file();

        return;

        // Handle allocation errors.
exit_no_right_window:
        win_destroy(slide_context->middle);
exit_no_middle_window:
        win_destroy(slide_context->left);
exit_no_left_window:
        membag_free(slide_context);
exit_no_context:
        app_desktop_restart();
        return;
}

void app_slideshow_pics_launch(struct workqueue_task *task)
{
        slide_launch_helper(task, SLIDE_PREFIX_PICS);
}

void app_slideshow_avr_launch(struct workqueue_task *task)
{
        slide_launch_helper(task, SLIDE_PREFIX_AVR);
}

void app_slideshow_uc3_launch(struct workqueue_task *task)
{
        slide_launch_helper(task, SLIDE_PREFIX_UC3);
}

void app_slideshow_xmega_launch(struct workqueue_task *task)
{
        slide_launch_helper(task, SLIDE_PREFIX_XMEGA);
}

void app_slideshow_dx_launch(struct workqueue_task *task)
{
        slide_launch_helper(task, SLIDE_PREFIX_DX);
}

---