/*

 * This file is part of libbluray

 * Copyright (C) 2010-2013  Petri Hintukainen <phintuka@users.sourceforge.net>

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Lesser General Public

 * License as published by the Free Software Foundation; either

 * version 2.1 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser General Public

 * License along with this library. If not, see

 * <http://www.gnu.org/licenses/>.

 */

#if HAVE_CONFIG_H

#include "config.h"

#endif

#include "graphics_controller.h"

#include "graphics_processor.h"

#include "hdmv_pids.h"

#include "ig.h"

#include "overlay.h"

#include "textst_render.h"

#include "rle.h"

#include "util/macro.h"

#include "util/logging.h"

#include "util/mutex.h"

#include "util/time.h"

#include "bdnav/uo_mask.h"

#include "../register.h"

#include "../keys.h"

#ifdef _WIN32

/* mingw: PRId64 seems to expands to %d without stdio.h ... */

#include <stdio.h>

#endif

#include <inttypes.h>

#include <string.h>

#define GC_ERROR(...) BD_DEBUG(DBG_GC | DBG_CRIT, __VA_ARGS__)

#define GC_TRACE(...) BD_DEBUG(DBG_GC,            __VA_ARGS__)

/*

 *

 */

typedef struct {

    uint16_t enabled_button;  /* enabled button id */

    uint16_t x, y, w, h;      /* button rect on overlay plane (if drawn) */

    int      visible_object_id; /* id of currently visible object */

    int      animate_indx;    /* currently showing object index of animated button, < 0 for static buttons */

    int      effect_running;  /* single-loop animation not yet complete */

} BOG_DATA;

struct graphics_controller_s {

    BD_REGISTERS   *regs;

    BD_MUTEX        mutex;

    /* overlay output */

    void           *overlay_proc_handle;

    void          (*overlay_proc)(void *, const struct bd_overlay_s * const);

    /* state */

    unsigned        ig_open;

    unsigned        ig_drawn;

    unsigned        ig_dirty;

    unsigned        pg_open;

    unsigned        pg_drawn;

    unsigned        pg_dirty;

    unsigned        popup_visible;

    unsigned        valid_mouse_position;

    unsigned        auto_action_triggered;

    BOG_DATA        bog_data[MAX_NUM_BOGS];

    BOG_DATA       *saved_bog_data;

    BD_UO_MASK      page_uo_mask;

    /* page effects */

    unsigned               effect_idx;

    BD_IG_EFFECT_SEQUENCE *in_effects;

    BD_IG_EFFECT_SEQUENCE *out_effects;

    int64_t                next_effect_time; /* 90 kHz */

    /* timers */

    int64_t                user_timeout;

    /* animated buttons */

    unsigned               frame_interval;

    unsigned               button_effect_running;

    unsigned               button_animation_running;

    /* data */

    PG_DISPLAY_SET *pgs;

    PG_DISPLAY_SET *igs;

    PG_DISPLAY_SET *tgs;  /* TextST */

    /* */

    GRAPHICS_PROCESSOR *pgp;

    GRAPHICS_PROCESSOR *igp;

    GRAPHICS_PROCESSOR *tgp;  /* TextST */

    /* */

    TEXTST_RENDER  *textst_render;

    int             next_dialog_idx;

    int             textst_user_style;

};

/*

 * object lookup

 */

static BD_PG_OBJECT *_find_object(PG_DISPLAY_SET *s, unsigned object_id)

{

    unsigned ii;

    for (ii = 0; ii < s->num_object; ii++) {

        if (s->object[ii].id == object_id) {

            return &s->object[ii];

        }

    }

    return NULL;

}

static BD_PG_PALETTE *_find_palette(PG_DISPLAY_SET *s, unsigned palette_id)

{

    unsigned ii;

    for (ii = 0; ii < s->num_palette; ii++) {

        if (s->palette[ii].id == palette_id) {

            return &s->palette[ii];

        }

    }

    return NULL;

}

static BD_IG_BUTTON *_find_button_bog(BD_IG_BOG *bog, unsigned button_id)

{

    unsigned ii;

    for (ii = 0; ii < bog->num_buttons; ii++) {

        if (bog->button[ii].id == button_id) {

            return &bog->button[ii];

        }

    }

    return NULL;

}

static BD_IG_BUTTON *_find_button_page(BD_IG_PAGE *page, unsigned button_id, unsigned *bog_idx)

{

    unsigned ii;

    for (ii = 0; ii < page->num_bogs; ii++) {

        BD_IG_BUTTON *button = _find_button_bog(&page->bog[ii], button_id);

        if (button) {

            if (bog_idx) {

                *bog_idx = ii;

            }

            return button;

        }

    }

    return NULL;

}

static BD_IG_PAGE *_find_page(BD_IG_INTERACTIVE_COMPOSITION *c, unsigned page_id)

{

    unsigned ii;

    for (ii = 0; ii < c->num_pages; ii++) {

        if (c->page[ii].id == page_id) {

            return &c->page[ii];

        }

    }

    return NULL;

}

enum { BTN_NORMAL, BTN_SELECTED, BTN_ACTIVATED };

static BD_PG_OBJECT *_find_object_for_button(PG_DISPLAY_SET *s,

                                             BD_IG_BUTTON *button, int state,

                                             BOG_DATA *bog_data)

{

    BD_PG_OBJECT *object   = NULL;

    unsigned object_id     = 0xffff;

    unsigned object_id_end = 0xffff;

    unsigned repeat        = 0;

    switch (state) {

        case BTN_NORMAL:

            object_id     = button->normal_start_object_id_ref;

            object_id_end = button->normal_end_object_id_ref;

            repeat        = button->normal_repeat_flag;

            break;

        case BTN_SELECTED:

            object_id     = button->selected_start_object_id_ref;

            object_id_end = button->selected_end_object_id_ref;

            repeat        = button->selected_repeat_flag;

            break;

        case BTN_ACTIVATED:

            object_id     = button->activated_start_object_id_ref;

            object_id_end = button->activated_end_object_id_ref;

            break;

    }

    if (bog_data) {

        bog_data->effect_running = 0;

        if (bog_data->animate_indx >= 0) {

            int range = object_id_end - object_id;

            if (range > 0 && object_id < 0xffff && object_id_end < 0xffff) {

                GC_TRACE("animate button #%d: animate_indx %d, range %d, repeat %d\n",

                         button->id, bog_data->animate_indx, range, repeat);

                object_id += bog_data->animate_indx % (range + 1);

                bog_data->animate_indx++;

                if (!repeat) {

                    if (bog_data->animate_indx > range) {

                        /* terminate animation to the last object */

                        bog_data->animate_indx = -1;

                    } else {

                        bog_data->effect_running = 1;

                    }

                }

            } else {

                /* no animation for this button */

                bog_data->animate_indx = -1;

            }

        } else {

            if (object_id_end < 0xfffe) {

                object_id = object_id_end;

            }

        }

    }

    object = _find_object(s, object_id);

    return object;

}

static BD_TEXTST_REGION_STYLE *_find_region_style(BD_TEXTST_DIALOG_STYLE *p, unsigned region_style_id)

{

    unsigned ii;

    for (ii = 0; ii < p->region_style_count; ii++) {

        if (p->region_style[ii].region_style_id == region_style_id) {

            return &p->region_style[ii];

        }

    }

    return NULL;

}

/*

 * util

 */

static int _areas_overlap(BOG_DATA *a, BOG_DATA *b)

{

    return !(a->x + a->w <= b->x        ||

             a->x        >= b->x + b->w ||

             a->y + a->h <= b->y        ||

             a->y        >= b->y + b->h);

}

static int _is_button_enabled(GRAPHICS_CONTROLLER *gc, BD_IG_PAGE *page, unsigned button_id)

{

    unsigned ii;

    for (ii = 0; ii < page->num_bogs; ii++) {

        if (gc->bog_data[ii].enabled_button == button_id) {

            return 1;

        }

    }

    return 0;

}

static uint16_t _find_selected_button_id(GRAPHICS_CONTROLLER *gc)

{

    /* executed when playback condition changes (ex. new page, popup-on, ...) */

    PG_DISPLAY_SET *s         = gc->igs;

    BD_IG_PAGE     *page      = NULL;

    unsigned        page_id   = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);

    unsigned        button_id = bd_psr_read(gc->regs, PSR_SELECTED_BUTTON_ID);

    unsigned        ii;

    page = _find_page(&s->ics->interactive_composition, page_id);

    if (!page) {

        GC_TRACE("_find_selected_button_id(): unknown page #%d (have %d pages)\n",

              page_id, s->ics->interactive_composition.num_pages);

        return 0xffff;

    }

    /* run 5.9.8.3 */

    /* 1) always use page->default_selected_button_id_ref if it is valid */

    if (_find_button_page(page, page->default_selected_button_id_ref, NULL) &&

        _is_button_enabled(gc, page, page->default_selected_button_id_ref)) {

        GC_TRACE("_find_selected_button_id() -> default #%d\n", page->default_selected_button_id_ref);

        return page->default_selected_button_id_ref;

    }

    /* 2) fallback to current PSR10 value if it is valid */

    for (ii = 0; ii < page->num_bogs; ii++) {

        BD_IG_BOG *bog = &page->bog[ii];

        uint16_t   enabled_button = gc->bog_data[ii].enabled_button;

        if (button_id == enabled_button) {

            if (_find_button_bog(bog, enabled_button)) {

                GC_TRACE("_find_selected_button_id() -> PSR10 #%d\n", enabled_button);

                return enabled_button;

            }

        }

    }

    /* 3) fallback to find first valid_button_id_ref from page */

    for (ii = 0; ii < page->num_bogs; ii++) {

        BD_IG_BOG *bog = &page->bog[ii];

        uint16_t   enabled_button = gc->bog_data[ii].enabled_button;

        if (_find_button_bog(bog, enabled_button)) {

            GC_TRACE("_find_selected_button_id() -> first valid #%d\n", enabled_button);

            return enabled_button;

        }

    }

    GC_TRACE("_find_selected_button_id(): not found -> 0xffff\n");

    return 0xffff;

}

static void _reset_user_timeout(GRAPHICS_CONTROLLER *gc)

{

    gc->user_timeout = 0;

    if (gc->igs->ics->interactive_composition.ui_model == IG_UI_MODEL_POPUP ||

        bd_psr_read(gc->regs, PSR_MENU_PAGE_ID) != 0) {

        gc->user_timeout = gc->igs->ics->interactive_composition.user_timeout_duration;

        if (gc->user_timeout) {

            gc->user_timeout += bd_get_scr();

        }

    }

}

static int _save_page_state(GRAPHICS_CONTROLLER *gc)

{

    if (!gc->igs || !gc->igs->ics) {

        GC_TRACE("_save_page_state(): no IG composition\n");

        return -1;

    }

    PG_DISPLAY_SET *s       = gc->igs;

    BD_IG_PAGE     *page    = NULL;

    unsigned        page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);

    unsigned        ii;

    page = _find_page(&s->ics->interactive_composition, page_id);

    if (!page) {

        GC_ERROR("_save_page_state(): unknown page #%d (have %d pages)\n",

              page_id, s->ics->interactive_composition.num_pages);

        return -1;

    }

    /* copy enabled button state, clear draw state */

    X_FREE(gc->saved_bog_data);

    gc->saved_bog_data = calloc(1, sizeof(gc->bog_data));

    if (!gc->saved_bog_data) {

        GC_ERROR("_save_page_state(): out of memory\n");

        return -1;

    }

    for (ii = 0; ii < page->num_bogs; ii++) {

        gc->saved_bog_data[ii].enabled_button = gc->bog_data[ii].enabled_button;

        gc->saved_bog_data[ii].animate_indx   = gc->bog_data[ii].animate_indx >= 0 ? 0 : -1;

    }

    return 1;

}

static int _restore_page_state(GRAPHICS_CONTROLLER *gc)

{

    gc->in_effects  = NULL;

    gc->out_effects = NULL;

    if (gc->saved_bog_data) {

        memcpy(gc->bog_data, gc->saved_bog_data, sizeof(gc->bog_data));

        X_FREE(gc->saved_bog_data);

        return 1;

    }

    return -1;

}

static void _reset_page_state(GRAPHICS_CONTROLLER *gc)

{

    PG_DISPLAY_SET *s       = gc->igs;

    BD_IG_PAGE     *page    = NULL;

    unsigned        page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);

    unsigned        ii;

    page = _find_page(&s->ics->interactive_composition, page_id);

    if (!page) {

        GC_ERROR("_reset_page_state(): unknown page #%d (have %d pages)\n",

              page_id, s->ics->interactive_composition.num_pages);

        return;

    }

    memset(gc->bog_data, 0, sizeof(gc->bog_data));

    for (ii = 0; ii < page->num_bogs; ii++) {

        gc->bog_data[ii].enabled_button = page->bog[ii].default_valid_button_id_ref;

        gc->bog_data[ii].animate_indx   = 0;

        gc->bog_data[ii].visible_object_id = -1;

    }

    /* animation frame rate */

    static const unsigned frame_interval[8] = {

        0,

        90000 / 1001 * 24,

        90000 / 1000 * 24,

        90000 / 1000 * 25,

        90000 / 1001 * 30,

        90000 / 1000 * 50,

        90000 / 1001 * 60,

    };

    gc->frame_interval = frame_interval[s->ics->video_descriptor.frame_rate] * (page->animation_frame_rate_code + 1);

    /* effects */

    gc->effect_idx  = 0;

    gc->in_effects  = NULL;

    gc->out_effects = NULL;

    /* timers */

    _reset_user_timeout(gc);

}

/*

 * overlay operations

 */

#if defined __GNUC__

#pragma GCC diagnostic ignored "-Wmissing-field-initializers"

#endif

static void _open_osd(GRAPHICS_CONTROLLER *gc, int plane,

                      unsigned x0, unsigned y0,

                      unsigned width, unsigned height)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd          = BD_OVERLAY_INIT;

        ov.pts          = -1;

        ov.plane        = plane;

        ov.x            = x0;

        ov.y            = y0;

        ov.w            = width;

        ov.h            = height;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

        if (plane == BD_OVERLAY_IG) {

            gc->ig_open = 1;

        } else {

            gc->pg_open = 1;

        }

    }

}

static void _close_osd(GRAPHICS_CONTROLLER *gc, int plane)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_CLOSE;

        ov.pts     = -1;

        ov.plane   = plane;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

    if (plane == BD_OVERLAY_IG) {

        gc->ig_open = 0;

        gc->ig_drawn = 0;

    } else {

        gc->pg_open = 0;

        gc->pg_drawn = 0;

    }

}

static void _flush_osd(GRAPHICS_CONTROLLER *gc, int plane, int64_t pts)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_FLUSH;

        ov.pts     = pts;

        ov.plane   = plane;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

}

static void _hide_osd(GRAPHICS_CONTROLLER *gc, int plane)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_HIDE;

        ov.plane   = plane;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

}

static void _clear_osd_area(GRAPHICS_CONTROLLER *gc, int plane, int64_t pts,

                            uint16_t x, uint16_t y, uint16_t w, uint16_t h)

{

    if (gc->overlay_proc) {

        /* wipe area */

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_WIPE;

        ov.pts     = pts;

        ov.plane   = plane;

        ov.x       = x;

        ov.y       = y;

        ov.w       = w;

        ov.h       = h;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

}

static void _clear_osd(GRAPHICS_CONTROLLER *gc, int plane)

{

    if (gc->overlay_proc) {

        /* clear plane */

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_CLEAR;

        ov.pts     = -1;

        ov.plane   = plane;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

    if (plane == BD_OVERLAY_IG) {

        gc->ig_drawn      = 0;

    } else {

        gc->pg_drawn      = 0;

    }

}

static void _clear_bog_area(GRAPHICS_CONTROLLER *gc, BOG_DATA *bog_data)

{

    if (gc->ig_drawn && bog_data->w && bog_data->h) {

        _clear_osd_area(gc, BD_OVERLAY_IG, -1, bog_data->x, bog_data->y, bog_data->w, bog_data->h);

        bog_data->x = bog_data->y = bog_data->w = bog_data->h = 0;

        bog_data->visible_object_id = -1;

        gc->ig_dirty = 1;

    }

}

static void _render_object(GRAPHICS_CONTROLLER *gc,

                           int64_t pts, unsigned plane,

                           uint16_t x, uint16_t y,

                           BD_PG_OBJECT *object,

                           BD_PG_PALETTE *palette)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_DRAW;

        ov.pts     = pts;

        ov.plane   = plane;

        ov.x       = x;

        ov.y       = y;

        ov.w       = object->width;

        ov.h       = object->height;

        ov.palette = palette->entry;

        ov.img     = object->img;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

}

static void _render_composition_object(GRAPHICS_CONTROLLER *gc,

                                       int64_t pts, unsigned plane,

                                       BD_PG_COMPOSITION_OBJECT *cobj,

                                       BD_PG_OBJECT *object,

                                       BD_PG_PALETTE *palette,

                                       int palette_update_flag)

{

    if (gc->overlay_proc) {

        BD_PG_RLE_ELEM *cropped_img = NULL;

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_DRAW;

        ov.pts     = pts;

        ov.plane   = plane;

        ov.x       = cobj->x;

        ov.y       = cobj->y;

        ov.w       = object->width;

        ov.h       = object->height;

        ov.palette = palette->entry;

        ov.img     = object->img;

        if (cobj->crop_flag) {

            if (cobj->crop_x || cobj->crop_y || cobj->crop_w != object->width) {

                cropped_img = rle_crop_object(object->img, object->width,

                                              cobj->crop_x, cobj->crop_y, cobj->crop_w, cobj->crop_h);

                if (!cropped_img) {

                    BD_DEBUG(DBG_DECODE | DBG_CRIT, "Error cropping PG object\n");

                    return;

                }

                ov.img = cropped_img;

            }

            ov.w  = cobj->crop_w;

            ov.h  = cobj->crop_h;

        }

        ov.palette_update_flag = palette_update_flag;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

        bd_refcnt_dec(cropped_img);

    }

}

static void _render_rle(GRAPHICS_CONTROLLER *gc,

                        int64_t pts,

                        BD_PG_RLE_ELEM *img,

                        uint16_t x, uint16_t y,

                        uint16_t width, uint16_t height,

                        BD_PG_PALETTE_ENTRY *palette)

{

    if (gc->overlay_proc) {

        BD_OVERLAY ov = {0};

        ov.cmd     = BD_OVERLAY_DRAW;

        ov.pts     = pts;

        ov.plane   = BD_OVERLAY_PG;

        ov.x       = x;

        ov.y       = y;

        ov.w       = width;

        ov.h       = height;

        ov.palette = palette;

        ov.img     = img;

        gc->overlay_proc(gc->overlay_proc_handle, &ov);

    }

}

/*

 * page selection and IG effects

 */

static void _select_button(GRAPHICS_CONTROLLER *gc, uint32_t button_id)

{

    BD_IG_PAGE     *page       = NULL;

    unsigned        page_id    = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);

    unsigned        bog_idx    = 0;

    /* reset animation */

    page = _find_page(&gc->igs->ics->interactive_composition, page_id);

    if (page && _find_button_page(page, button_id, &bog_idx)) {

        gc->bog_data[bog_idx].animate_indx = 0;

        gc->next_effect_time = bd_get_scr();

    }

    /* select page */

    bd_psr_write(gc->regs, PSR_SELECTED_BUTTON_ID, button_id);

    gc->auto_action_triggered = 0;

}

static void _select_page(GRAPHICS_CONTROLLER *gc, uint16_t page_id, int out_effects)

{

    unsigned cur_page_id = bd_psr_read(gc->regs, PSR_MENU_PAGE_ID);

    BD_IG_PAGE *page = NULL;

    bd_psr_write(gc->regs, PSR_MENU_PAGE_ID, page_id);

    _reset_page_state(gc);

    uint16_t button_id = _find_selected_button_id(gc);

    _select_button(gc, button_id);

    gc->valid_mouse_position = 0;

    if (out_effects) {

        page = _find_page(&gc->igs->ics->interactive_composition, cur_page_id);

        if (page && page->out_effects.num_effects) {

            gc->next_effect_time = bd_get_scr();

            gc->out_effects = &page->out_effects;

        }

    }

    page = _find_page(&gc->igs->ics->interactive_composition, page_id);

    if (page && page->in_effects.num_effects) {

        gc->next_effect_time = bd_get_scr();

        gc->in_effects = &page->in_effects;

    }

    if (gc->ig_open && !gc->out_effects) {

        _clear_osd(gc, BD_OVERLAY_IG);

    }

}

static void _gc_reset(GRAPHICS_CONTROLLER *gc)

{

    if (gc->pg_open) {

        _close_osd(gc, BD_OVERLAY_PG);

    }

    if (gc->ig_open) {

        _close_osd(gc, BD_OVERLAY_IG);

    }

    gc->popup_visible = 0;

    gc->valid_mouse_position = 0;

    gc->page_uo_mask = uo_mask_get_empty();

    graphics_processor_free(&gc->igp);

    graphics_processor_free(&gc->pgp);

    graphics_processor_free(&gc->tgp);

    pg_display_set_free(&gc->pgs);

    pg_display_set_free(&gc->igs);

    pg_display_set_free(&gc->tgs);

    textst_render_free(&gc->textst_render);

    gc->next_dialog_idx = 0;

    gc->textst_user_style = -1;

    memset(gc->bog_data, 0, sizeof(gc->bog_data));

}

/*

 * register hook

 */

static void _process_psr_event(void *handle, BD_PSR_EVENT *ev)

{

    GRAPHICS_CONTROLLER *gc = (GRAPHICS_CONTROLLER *)handle;

    if (ev->ev_type == BD_PSR_SAVE) {

        BD_DEBUG(DBG_GC, "PSR SAVE event\n");

        /* save menu page state */

        bd_mutex_lock(&gc->mutex);

        _save_page_state(gc);

        bd_mutex_unlock(&gc->mutex);

        return;

    }

    if (ev->ev_type == BD_PSR_RESTORE) {

        switch (ev->psr_idx) {

            case PSR_SELECTED_BUTTON_ID:

              return;

            case PSR_MENU_PAGE_ID:

                /* restore menus */

                bd_mutex_lock(&gc->mutex);

                _restore_page_state(gc);

                bd_mutex_unlock(&gc->mutex);

                return;

            default:

                /* others: ignore */

                return;

        }

    }

}

/*

 * init / free

 */

GRAPHICS_CONTROLLER *gc_init(BD_REGISTERS *regs, void *handle, gc_overlay_proc_f func)

{

    GRAPHICS_CONTROLLER *p = calloc(1, sizeof(*p));

    if (!p) {

        GC_ERROR("gc_init(): out of memory\n");

        return NULL;

    }

    p->regs = regs;

    p->overlay_proc_handle = handle;

    p->overlay_proc        = func;

    bd_mutex_init(&p->mutex);

    bd_psr_register_cb(regs, _process_psr_event, p);

    p->textst_user_style = -1;

    return p;

}

void gc_free(GRAPHICS_CONTROLLER **p)

{

    if (p && *p) {

        GRAPHICS_CONTROLLER *gc = *p;

        bd_psr_unregister_cb(gc->regs, _process_psr_event, gc);

        _gc_reset(gc);

        if (gc->overlay_proc) {

            gc->overlay_proc(gc->overlay_proc_handle, NULL);

        }

        bd_mutex_destroy(&gc->mutex);

        X_FREE(gc->saved_bog_data);

        X_FREE(*p);

    }

}

/*

 * graphics stream input

 */

int gc_decode_ts(GRAPHICS_CONTROLLER *gc, uint16_t pid, uint8_t *block, unsigned num_blocks, int64_t stc)

{

    if (!gc) {

        GC_TRACE("gc_decode_ts(): no graphics controller\n");

        return -1;

    }

    if (IS_HDMV_PID_IG(pid)) {

        /* IG stream */

        if (!gc->igp) {

            gc->igp = graphics_processor_init();

            if (!gc->igp) {

                return -1;

            }

        }

        bd_mutex_lock(&gc->mutex);

        if (!graphics_processor_decode_ts(gc->igp, &gc->igs,

                                          pid, block, num_blocks,

                                          stc)) {

            /* no new complete display set */

            bd_mutex_unlock(&gc->mutex);

            return 0;

        }

        if (!gc->igs || !gc->igs->complete) {

            bd_mutex_unlock(&gc->mutex);

            return 0;

        }

        /* TODO: */

        if (gc->igs->ics) {

            if (gc->igs->ics->interactive_composition.composition_timeout_pts > 0) {

                GC_TRACE("gc_decode_ts(): IG composition_timeout_pts not implemented\n");

            }

            if (gc->igs->ics->interactive_composition.selection_timeout_pts) {

                GC_TRACE("gc_decode_ts(): IG selection_timeout_pts not implemented\n");

            }

            if (gc->igs->ics->interactive_composition.user_timeout_duration) {

                GC_TRACE("gc_decode_ts(): IG user_timeout_duration %d\n",

                         gc->igs->ics->interactive_composition.user_timeout_duration);