action_stack.c-Dateireferenz

#include "camera_info.h"
#include "modes.h"
#include "clock.h"
#include "shooting.h"
#include "console.h"
#include "conf.h"
#include "keyboard.h"
#include "histogram.h"
#include "action_stack.h"
#include "script_api.h"

Include-Abhängigkeitsdiagramm für action_stack.c:

gehe zum Quellcode dieser Datei

Datenstrukturen
struct	_action_stack

Makrodefinitionen
#define	AS_FUNC_ENTRY   0xa32f1c9e
#define	ACTION_STACK_SIZE   48
#define	MAX_ACTION_STACKS   5

Typdefinitionen
typedef struct _action_stack	action_stack_t

Funktionen
int	action_stack_is_finished (AS_ID comp_id)
AS_ID	action_stack_create (action_func proc_func)
static void	action_stack_finish (action_stack_t *p)
void	action_stack_kill (AS_ID comp_id)
long	action_top (int n)
long	action_pop ()
long	action_pop_func (int nParam)
void	action_push (long p)
void	action_push_func (action_func f)
static int	action_process_delay (long delay)
void	action_pop_delay ()
static int	action_stack_AS_SLEEP ()
void	action_push_delay (long msec)
static int	action_stack_AS_PRESS ()
void	action_push_press (long key)
static int	action_stack_AS_RELEASE ()
void	action_push_release (long key)
void	action_push_click (long key)
static int	action_stack_AS_WAIT_SHOOTING_DONE ()
static int	action_stack_AS_WAIT_FLASH ()
static int	action_stack_AS_WAIT_SHOOTING_IN_PROGRESS ()
void	action_push_shoot (int retry)
int	action_stack_AS_SHOOT ()
static void	action_stack_process ()
void	action_stack_process_all ()

Variablen
static action_stack_t *	action_stacks = NULL
static action_stack_t *	active_stack = NULL
static action_stack_t *	free_stacks = NULL
static int	num_stacks = 0
static AS_ID	task_comp_id = 1

Makro-Dokumentation

#define ACTION_STACK_SIZE   48

Definiert in Zeile 19 der Datei action_stack.c.

#define AS_FUNC_ENTRY   0xa32f1c9e

Definiert in Zeile 14 der Datei action_stack.c.

#define MAX_ACTION_STACKS   5

Definiert in Zeile 20 der Datei action_stack.c.

Dokumentation der benutzerdefinierten Typen

typedef struct _action_stack action_stack_t

Dokumentation der Funktionen

long action_pop

(

)

Definiert in Zeile 172 der Datei action_stack.c.

{
    if (active_stack)
        return active_stack->stack[active_stack->stack_ptr--];
    return 0;
}

void action_pop_delay

(

)

Definiert in Zeile 234 der Datei action_stack.c.

{
    active_stack->delay_target_ticks = 0;
    action_pop_func(1);
}

long action_pop_func

(

int

nParam)

Definiert in Zeile 181 der Datei action_stack.c.

{
    for (; nParam >= 0; nParam--)
        action_pop();
    return action_pop();    // Return function pointer / last parameter
}

static int action_process_delay ( long  delay)

static

Definiert in Zeile 209 der Datei action_stack.c.

{
    unsigned t = get_tick_count();
    // FIXME take care if overflow occurs
    if (active_stack->delay_target_ticks == 0)
    {
        /* delay of -1 signals indefinite (actually 1 day) delay*/
        if(delay == -1)
            delay = 86400000;

        active_stack->delay_target_ticks = t+delay;
        return 0;
    }
    if (active_stack->delay_target_ticks <= t)
    {
        return 1;
    }
    return 0;
}

void action_push

(

long

p)

Definiert in Zeile 190 der Datei action_stack.c.

{
    if (active_stack)
        active_stack->stack[++active_stack->stack_ptr] = p;
}

void action_push_click

(

long

key)

Definiert in Zeile 300 der Datei action_stack.c.

{
    // WARNING stack program flow is reversed
    action_push_release(key);
    action_push_press(key);
}

void action_push_delay

(

long

msec)

Definiert in Zeile 256 der Datei action_stack.c.

{
    action_push(msec);
    action_push_func(action_stack_AS_SLEEP);
}

void action_push_func

(

action_func

f)

Definiert in Zeile 197 der Datei action_stack.c.

{
    action_push((long)f);
    action_push(AS_FUNC_ENTRY);
}

void action_push_press

(

long

key)

Definiert in Zeile 272 der Datei action_stack.c.

{
    // WARNING stack program flow is reversed
    action_push_delay(camera_info.cam_key_press_delay);
    action_push(key);
    action_push_func(action_stack_AS_PRESS);
}

void action_push_release

(

long

key)

Definiert in Zeile 290 der Datei action_stack.c.

{
    // WARNING stack program flow is reversed
    action_push_delay(camera_info.cam_key_release_delay);
    action_push(key);
    action_push_func(action_stack_AS_RELEASE);
}

void action_push_shoot

(

int

retry)

Definiert in Zeile 406 der Datei action_stack.c.

{
    // Init shooting state
    camera_info.state.state_shooting_progress = SHOOTING_PROGRESS_NONE;

    // Wait for camera ready to shoot or timeout
    action_push(retry);
    action_push(get_tick_count() + 5000);
    action_push_func(action_stack_AS_WAIT_SHOOTING_IN_PROGRESS);

    // Half press shutter
    action_push_press(KEY_SHOOT_HALF);
}

static int action_stack_AS_PRESS ( )

static

Definiert in Zeile 263 der Datei action_stack.c.

{
    long skey = action_pop_func(1); // Key parameter returned
    kbd_key_press(skey);
    return 1;
}

static int action_stack_AS_RELEASE ( )

static

Definiert in Zeile 281 der Datei action_stack.c.

{
    long skey = action_pop_func(1); // Key parameter returned
    kbd_key_release(skey);
    return 1;
}

int action_stack_AS_SHOOT

(

void

)

Definiert in Zeile 420 der Datei action_stack.c.

{
    // Remove this action from stack
    action_pop_func(0);

    // Push the shoot actions (with retry on shoot failure)
    action_push_shoot(1);

    return 1;
}

static int action_stack_AS_SLEEP ( )

static

Definiert in Zeile 241 der Datei action_stack.c.

{
    long delay = action_top(2);

    if (action_process_delay(delay))
    {
        action_pop_delay();
        return 1;
    }

    return 0;
}

static int action_stack_AS_WAIT_FLASH ( )

static

Definiert in Zeile 354 der Datei action_stack.c.

{
    if (shooting_is_flash_ready())
    {
        action_pop_func(0);
        return 1;
    }
    return 0;
}

static int action_stack_AS_WAIT_SHOOTING_DONE ( )

static

Definiert in Zeile 312 der Datei action_stack.c.

{
    // Are we there yet?
    if (!shooting_in_progress())
    {
        // Remove this action from stack
        int retry = action_pop_func(1); // Retry parameter returned

        // Check if shoot succeeded or not
        if (camera_info.state.state_shooting_progress == SHOOTING_PROGRESS_NONE)
        {
            if (retry)
            {
                // Shoot failed, retry once, if it fails again give up
                action_push_shoot(0);

                // Short delay before retrying shoot
                action_push_delay(250);
            }
            else
            {
                // Failed - already retried, or no retry requested
                // Return 'shoot' status to script - 2 = shoot failed
                libscriptapi->set_as_ret(2);
            }
        }
        else
        {
            // Return 'shoot' status to script - 0 = shoot succesful
            libscriptapi->set_as_ret(0);

            // Final script config delay (XXX FIXME find out how to wait to jpeg save finished)
            if (conf.script_shoot_delay > 0)
                action_push_delay(conf.script_shoot_delay*100);
        }

        return 1;
    }
    return 0;
}

static int action_stack_AS_WAIT_SHOOTING_IN_PROGRESS ( )

static

Definiert in Zeile 366 der Datei action_stack.c.

{
    // Get parameters
    int timeout = action_top(2);
    int retry = action_top(3);

    if (shooting_in_progress() || camera_info.state.mode_video)
    {
        // Remove this action from the stack
        action_pop_func(2);

        // Push the rest of the shoot actions onto the stack (reversed flow)

        // Push 'retry if failed' parameter for exit action
        action_push(retry);
        action_push_func(action_stack_AS_WAIT_SHOOTING_DONE);

        // Full press shutter
        action_push_click(KEY_SHOOT_FULL);

        // Wait for flash recharged
        action_push_func(action_stack_AS_WAIT_FLASH);

        return 1;
    }
    if (get_tick_count() >= timeout)
    {
        // Remove this action from the stack
        action_pop_func(2);

        // Return 'shoot' status to script - 1 = shutter half press timed out
        libscriptapi->set_as_ret(1);

        return 1;
    }
    return 0;
}

AS_ID action_stack_create

(

action_func

proc_func)

Definiert in Zeile 62 der Datei action_stack.c.

{
    // Cap the maximum number of action_stacks
    if (num_stacks == MAX_ACTION_STACKS)
        return -1;

    // Initialize new action stack
    action_stack_t* stack = 0;
    if (free_stacks)
    {
        // Reuse previous memory block
        stack = free_stacks;
        free_stacks = free_stacks->next;
    }
    else
    {
        // Get a new block
        stack = (action_stack_t*)malloc(sizeof(action_stack_t));
    }
    memset(stack,0,sizeof(action_stack_t));

    // Insert at start of list - stacks execute in order of most recent creation
    stack->next = action_stacks;
    action_stacks = stack;

    // Initialize id & processing function
    stack->comp_id = task_comp_id;
    stack->stack[0] = (long)proc_func;
    stack->stack[1] = AS_FUNC_ENTRY;    // Can't use action_push_func as active_stack not set
    stack->stack_ptr = 1;

    ++num_stacks;

    // Increment task_comp_id
    // For this to clash with a running stack you would need to leave one running
    // while 4 billion more were created - highly unlikely.
    ++task_comp_id;
    // Reset just in case it wraps around to 'finished' value
    if (task_comp_id == 0) task_comp_id = 1;

    return stack->comp_id;
}

static void action_stack_finish ( action_stack_t *  p)

static

Definiert in Zeile 106 der Datei action_stack.c.

{
    // Check in case already finalised
    if (p->comp_id == 0) return;

    // Remove 'active_stack' from the list since it is done execuing
    if (p == action_stacks)
    {
        action_stacks = action_stacks->next;
    }
    else
    {
        action_stack_t* prev = action_stacks;
        while (prev && (prev->next != p))
        {
            prev = prev->next;
        }
        if (prev)
        {
            prev->next = prev->next->next;
        }
    }

    --num_stacks;

    // Mark as free in case this function gets called again
    p->comp_id = 0;
    p->stack_ptr = -1;

    // Instead of freeing memory, save it to the free list
    // Next time this block will be reused
    p->next = free_stacks;
    free_stacks = p;
}

int action_stack_is_finished

(

AS_ID

comp_id)

Definiert in Zeile 45 der Datei action_stack.c.

{
    action_stack_t *p = action_stacks;
    while (p)
    {
        if (p->comp_id == comp_id)
            return 0;
        p = p->next;
    }

    return 1;
}

void action_stack_kill

(

AS_ID

comp_id)

Definiert in Zeile 143 der Datei action_stack.c.

{
    action_stack_t *p = action_stacks;
    while (p)
    {
        if (p->comp_id == comp_id)
        {
            action_stack_finish(p);
            return;
        }
        p = p->next;
    }
}

static void action_stack_process ( )

static

Definiert in Zeile 435 der Datei action_stack.c.

{
    int process = 1;

    while (process && (active_stack->stack_ptr >= 0))
    {
        // Get function address and id from stack
        long id = action_top(0);
        action_func f = (action_func)action_top(1);
        if (id == (long)AS_FUNC_ENTRY)    // Safety check
        {
            process = f();
        }
        else
        {
            char buf[100];
            sprintf(buf,"AS Error - Not a Function. Aborting. %d %08x %08x.",active_stack->stack_ptr,id,f);
            script_console_add_error((long)buf);
            action_stack_finish(active_stack);
            return;
        }
    }

    if (active_stack->stack_ptr < 0)
    {
        action_stack_finish(active_stack);
    }
}

void action_stack_process_all

(

)

Definiert in Zeile 465 der Datei action_stack.c.

{
    active_stack = action_stacks;

    while (active_stack)
    {
        // Save the next stack in case the current one ends and 
        // releases it's stack during execution
        action_stack_t *next = active_stack->next;

        // Process stack functions
        action_stack_process();

        active_stack = next;
    }
}

long action_top

(

int

n)

Definiert in Zeile 163 der Datei action_stack.c.

{
    if (active_stack)
        return active_stack->stack[active_stack->stack_ptr-n];
    return 0;
}

Variablen-Dokumentation

action_stack_t* action_stacks = NULL

static

Definiert in Zeile 34 der Datei action_stack.c.

action_stack_t* active_stack = NULL

static

Definiert in Zeile 35 der Datei action_stack.c.

action_stack_t* free_stacks = NULL

static

Definiert in Zeile 36 der Datei action_stack.c.

int num_stacks = 0

static

Definiert in Zeile 37 der Datei action_stack.c.

AS_ID task_comp_id = 1

static

Definiert in Zeile 38 der Datei action_stack.c.