source: svn/trunk/newcon3bcm2_21bu/dta/src/sim/sim_settop.c

/***************************************************************************
 * Copyright (c) 2012, Broadcom Corporation
 * All Rights Reserved
 * Confidential Property of Broadcom Corporation
 *
 * THIS SOFTWARE MAY ONLY BE USED SUBJECT TO AN EXECUTED SOFTWARE LICENSE
 * AGREEMENT  BETWEEN THE USER AND BROADCOM.  YOU HAVE NO RIGHT TO USE OR
 * EXPLOIT THIS MATERIAL EXCEPT SUBJECT TO THE TERMS OF SUCH AN AGREEMENT.
 *
 * $brcm_Workfile:  $
 * $brcm_Revision:  $
 * $brcm_Date: $
 *
 * Module Description:
 *
 * Revision History:
 *
 * $brcm_Log:  $
 *
 ***************************************************************************/
#include "led.h"
#include "ministd.h"
#include "bsettop_types.h"
#include "bsettop.h"
#include "bsettop_tuner.h"
#include "bsettop_decode_audio.h"
#include "bsettop_decode.h"
#include "bsettop_display.h"
#include "bsettop_hdmi.h"
#include "bsettop_rfm.h"
#include "bgfx.h"
#include "bspi_flash.h"

unsigned led_set_mode(enum led_mode_t mode)
{
        return 0;
}
unsigned led_update(unsigned elapsed_time)
{
        return 0;
}

#define DBG_PRINT(x)    printf x

#define OSD_WIDTH       720
#if DISPLAY_NTSC
#define OSD_HEIGHT      480
#else
#if DISPLAY_PAL
#define OSD_HEIGHT      576
#else
#error display format (NTSC or PAL) must be defined
#endif
#endif
#define OSD_PITCH       (720/2)
#define NUM_EVENTS      2

#define GRC_TOP_SLOT 0
#define GRC_BOT_SLOT 1

#define FIELD_MASK      ((1UL << GRC_TOP_SLOT) | (1UL << GRC_BOT_SLOT))

#define MUTEX_TIMEOUT   100 /* milliseconds */
#define PEND_TIMEOUT    100 /* milliseconds */

typedef enum bgraphics_state_t
{
        eGS_UNINITIALIZED,
        eGS_DEFAULT,
        eGS_PALETTE_SET,
        eGS_PALETTE_LOADED,
        eGS_FB_SET,
}bgraphics_state_t;

struct bgraphics
{
        bgraphics_state_t       state;
        unsigned int    surf_idx;
        unsigned int    field_mask;
        unsigned int    *p_palette;
        int             format;         /* P4 and RGB format */
        int             pitch;          /* pitch associated with format to use */
        int                     bpp;
        b_queue_t               queue;
        b_mutex_t       mutex;
        b_event_t               events[NUM_EVENTS];
        bgfx_surf_t     surf[2];
};
static struct bgraphics s_graphics = { eGS_UNINITIALIZED, 0, 0, NULL , bgraphics_pixel_format_a8_r8_g8_b8, OSD_PITCH * 8,32 };
extern void get_osd_info(unsigned char **pixels, int *pitch, int *width, int *height);
extern void update_osd();
bgraphics_t bgraphics_open( bobject_t id, bdisplay_t display)
{
        unsigned int flags;
        unsigned char *p_surf;
        unsigned char *pixels;
        uint16_t s_width, s_height, s_pitch;
        int pitch,width,height,bpp;

        get_osd_info(&pixels,&pitch,&width,&height);
        s_pitch = (uint16_t)pitch;
        s_width = (uint16_t)width;
        s_height = (uint16_t)height;
        if (s_graphics.state > eGS_UNINITIALIZED)
                return (bgraphics_t)0;

        switch (s_graphics.format)
        {
                case bgraphics_pixel_format_a8_r8_g8_b8:
                case bgraphics_pixel_format_y08_cb8_y18_cr8:
                        pitch = width * 4;
                        bpp = 32;
                        break;
#if 0
                case bgraphics_pixel_format_r5_g6_b5:
                case bgraphics_pixel_format_a1_r5_g5_b5:
                case bgraphics_pixel_format_r5_g5_b5_a1:
                case bgraphics_pixel_format_a4_r4_g4_b4:
                case bgraphics_pixel_format_r4_g4_b4_a4:
                pitch = width * 2;
                        bpp = 16;
                        break;

                case bgraphics_pixel_format_palette4:
                        pitch = width / 2;
                        bpp = 4
                        break;
#endif
                default:
                        DBG_PRINT(("%s: unsupported foramt %d", __func__, s_graphics.format));
                        return (bgraphics_t)0;
        }
        if (bgfx_create(&s_graphics.surf[0],width,height,NULL, 
                                pitch,NULL,BGFX_SURF_BPP(bpp)|BGFX_SURF_RGB) != 0)
        {
                BDBG_ASSERT(0);
        }
        if (bgfx_create(&s_graphics.surf[1],width,height,NULL, 
                                pitch,NULL,BGFX_SURF_BPP(bpp)|BGFX_SURF_RGB) != 0)
        {
                BDBG_ASSERT(0);
        }

        s_graphics.state = eGS_DEFAULT;
        s_graphics.pitch = s_graphics.surf[0].surface.pitch;

        return (bgraphics_t)&s_graphics;
}

void bgraphics_close(
        bgraphics_t graphics    /* handle returned by bgraphics_open */
        )
{
        bgfx_destroy(&(s_graphics.surf[0]));
}

void bgraphics_get(
        bgraphics_settings *settings /* [out] */
        )
{
}

bresult bgraphics_set(
        const bgraphics_settings *settings
        )
{
        return b_ok;
}

/* Convert ARGB to ABGR */
static inline unsigned int argb_to_abgr(uint32_t pixel)
{
        if ((pixel && 0xFF000000) == 0x00000000) {
                return 0xFF000000;
        }
        return ((0xFF00FF00 & pixel) | ((0x00FF0000 & pixel) >> 16) | ((0x000000FF & pixel) << 16));
}

/*  ARGB to ABGR with source alpha blend */
static inline unsigned int argb_to_abgr_w_qalpha(uint32_t src_pixel,uint32_t dst_pixel)
{
        if ((src_pixel && 0xFF000000) == 0x00000000) {
                return dst_pixel;
        }
        return ((0xFF00FF00 & src_pixel) | ((0x00FF0000 & src_pixel) >> 16) | ((0x000000FF & src_pixel) << 16));
}


static inline uint32_t bgfx_blend_argb_pixels(uint32_t s_pixel,uint32_t d_pixel)
{
        uint32_t sr,sg,sb,sa,dr,dg,db,da,oa;
        sa = (s_pixel >> 24) & 0xFF;
        da = (d_pixel >> 24) & 0xFF;
        if ((sa == 0xFF) || (da == 0x00))
        {
                return s_pixel;
        }
        if ((da == 0xFF) && (sa == 0x00))
        {
                return d_pixel;
        }
        
        sr = (s_pixel >> 16) & 0xFF;
        sg = (s_pixel >> 8) & 0xFF;
        sb = (s_pixel >> 0) & 0xFF;
        dr = (d_pixel >> 16) & 0xFF;
        dg = (d_pixel >> 8) & 0xFF;
        db = (d_pixel >> 0) & 0xFF;

        dr = (((sr * sa)/0xFF) & 0xFF) + ((((0xFF - sa) * dr)/0xFF) & 0xFF);
        dg = (((sg * sa)/0xFF) & 0xFF) + ((((0xFF - sa) * dg)/0xFF) & 0xFF);
        db = (((sb * sa)/0xFF) & 0xFF) + ((((0xFF - sa) * db)/0xFF) & 0xFF);

        oa = da;

        return (oa << 24) | (dr << 16) | (dg << 8) | db;
}

bresult bgraphics_sync(
        bgraphics_t g,  /* handle returned by bgraphics_open */
        bool overlay    /* overlay is popped or not */
        )
{
        uint8_t *pixels,*src_pixels;
        uint32_t *dst,*src;
        int x,y,pitch,width,height;
        get_osd_info(&pixels,&pitch,&width,&height);

        printf("%s:%d\n",__FUNCTION__,__LINE__);
        src_pixels = g->surf[0].surface.buf;
        for (y = 0; y < height; ++y) 
        {
                dst = (uint32_t*)pixels;
                src = (uint32_t*)src_pixels;
                for (x = 0; x < width; ++x) 
                {
                        dst[x] = 0xFF000000;
                        dst[x] = bgfx_blend_argb_pixels(src[x],dst[x]);
                        if (!overlay)
                                dst[x] = argb_to_abgr(dst[x]);
                        //dst[x] = argb_to_abgr(src[x]);
                }
                pixels += pitch;
                src_pixels += g->surf[0].surface.pitch;
        }

        if (overlay) 
        {
                get_osd_info(&pixels,&pitch,&width,&height);
                src_pixels = g->surf[1].surface.buf;
                for (y = 0; y < height; ++y) 
                {
                        dst = (uint32_t*)pixels;
                        src = (uint32_t*)src_pixels;
                        for (x = 0; x < width; ++x) 
                        {
                                //dst[x] = argb_to_abgr_w_qalpha(src[x],dst[x]);
                                dst[x] = argb_to_abgr(bgfx_blend_argb_pixels(src[x],dst[x]));
                        }
                        pixels += pitch;
                        src_pixels += g->surf[0].surface.pitch;
                }
        }
        update_osd();
        return b_ok;
}
bresult bgraphics_sync_partial(
        bgraphics_t g,  /* handle returned by bgraphics_open */
        bgraphics_id id,
        bool overlay    /* overlay is popped or not */
        )
{
        return b_ok;
}


bresult bgraphics_get_framebuffer(
        bgraphics_t graphics,    /* handle returned by bgraphics_open */
        void **buffer,                  /* [out] address of framebuffer memory */
        unsigned int **palette, /* [out] address of palette */
        int *width,                             /* [out] width of the OSD surface  */
        int *height,                    /* [out] height of the OSD surface  */
        int *pitch                              /* [out] pitch of the OSD surface  */
        )
{
        *buffer = s_graphics.surf[0].surface.buf;
        *palette = s_graphics.p_palette;
        *width = s_graphics.surf[0].surface.width;
        *height = s_graphics.surf[0].surface.height;
        *pitch = s_graphics.surf[0].surface.pitch;
        return b_ok;
}

bresult bgraphics_get_osd_params(bgraphics_t graphics, 
                                                                 bsettop_surf_t *p_osd_surf,
                                                                 void **osd_buffer,
                                                                 bsettop_surf_t *p_overlay_surf,
                                                                 void **overlay_mem)
{
        *p_osd_surf = NULL;
        *osd_buffer = s_graphics.surf[0].surface.buf;
        if (overlay_mem) 
        {
                *p_overlay_surf = NULL;
                *overlay_mem = s_graphics.surf[1].surface.buf;
        }

        return b_ok;
}
bresult bsurface_create_surface(uint32_t width, 
                                                                uint32_t height, 
                                                                bgraphics_pixel_format format, 
                                                                uint8_t **mem, 
                                                                uint32_t *pitch, 
                                                                bsettop_surf_t *p_settop_surf)
{
        *mem = (uint8_t*)1;
        return b_ok;
}


bresult bgraphics_load_palette(
        bgraphics_t g    /* handle returned by bgraphics_open */
        )
{
        return b_ok;
}

baudio_decode_t baudio_decode_open(bobject_t id)
{
        return (baudio_decode_t)1;
}
void baudio_decode_close(baudio_decode_t codec)
{
}
bresult baudio_decode_start(baudio_decode_t codec, 
                                                        bdisplay_t display, 
                                                        bstream_t stream)
{
        return b_ok;
}
void baudio_decode_stop(baudio_decode_t codec)
{
}
bresult baudio_decode_get_status(baudio_decode_t codec, 
                                                                 baudio_decode_status *status)
{
        return b_ok;
}

void baudio_decode_get_config(baudio_decode_t codec, 
                                                          baudio_decode_config *config)
{
}

bresult baudio_decode_set_config(baudio_decode_t codec, 
                                                                 const baudio_decode_config *config)
{
        return b_ok;
}

void baudio_decode_get_avl_level(baudio_decode_t audio, int num_energy, long *level)
{
        *level = 0;
}
void baudio_decode_test_tone(baudio_decode_t audio, 
                                                         uint32_t *samples, /* array of samples, num_samples long */
                                                         uint32_t num_samples, /* Number of samples, should be less than sample array size */
                                                         bool leftChannel,      /* true - program left channel, flase program right channel */
                                                         bool enable /* enable/disable hifidac tone test */
                                                         )
{
}

bdecode_t bdecode_open(
        bobject_t decode_id /* decode object id */
        )
{
        return (bdecode_t)1;
}

void bdecode_close(
        bdecode_t decode /* handle returned by bdecode_open */
        )
{
}
bresult bdecode_start(
        bdecode_t decode, /* handle returned by bdecode_open */
        bstream_t source, /* source for the decode, either analog or digital */
        bdecode_window_t window /* window to render decode */
        )
{
        return b_ok;
}
void bdecode_stop(
        bdecode_t decode /* handle returned by bdecode_open */
        )
{
}

bresult bdecode_get_status(
        bdecode_t decode,  /* handle returned by bdecode_open */
        bdecode_status *status  /* [out] status to be populated */
        )
{
        return b_ok;
}

void bdecode_set_config(
        bdecode_t decode,               /* handle returned by bdecode_open */
        bdecode_config *p_cfg   /* configuration structure reference */
        )
{
}

void bdecode_get_config(
        bdecode_t decode,               /* handle returned by bdecode_open */
        bdecode_config *p_cfg   /* [out] configuration to be populated */
        )
{
}

bdisplay_t bdisplay_open(
                                                bobject_t display_id /* handle used to identify a particular display */
                                                )
{
        return (bdisplay_t)1;
}


void bdisplay_close(
                                   bdisplay_t display /* handle returned by bdisplay_open */
                                   )
{
}


boutput_rf_t
boutput_rf_open( bobject_t rfmod_id )
{
        return (boutput_rf_t)1;
}


boutput_spdif_t
boutput_spdif_open(bobject_t spdif_id)
{
        return (boutput_spdif_t)1;
}


boutput_i2s_t
boutput_i2s_open(bobject_t i2s_id)
{
        return (boutput_i2s_t)1;
}



bresult
bdisplay_set(
                        bdisplay_t display,     /* handle returned by bdisplay_open */
                        bdisplay_settings *settings     /* desired display settings */
                        )
{
        return b_ok;
}


void
bdisplay_get(
                        bdisplay_t display,     /* handle returned by bdisplay_open */
                        bdisplay_settings *settings     /* [out] current settings of display */
                        )
{
}


bresult boutput_rf_set(boutput_rf_t rf, 
                                           const boutput_rf_settings *settings
                                          )
{
        return b_ok;
}



void boutput_rf_get(boutput_rf_t rf,
                                        boutput_rf_settings *settings /* [out] */
                                   )
{
}


bresult boutput_spdif_set(boutput_spdif_t spdif, 
                                                  const boutput_spdif_settings *settings
                                                 )
{
        return b_ok;
}


void boutput_spdif_get(boutput_spdif_t spdif, 
                                           boutput_spdif_settings *settings     /* [out] */
                                          )
{
}


bresult boutput_i2s_set(boutput_i2s_t i2s, 
                                                const boutput_i2s_settings *settings
                                           )
{
        return b_ok;
}

void boutput_i2s_get(boutput_i2s_t i2s, 
                                         boutput_i2s_settings *settings /* [out] */
                                        )
{
}


bresult boutput_rf_set_audio_volume(
                                                                   boutput_rf_t rf,
                                                                   unsigned int volume /* desired volume */
                                                                   )
{
        return b_ok;
}

bresult boutput_rf_get_audio_volume(
                                                                   boutput_rf_t rf,
                                                                   unsigned int *volume   /* [out] current volume of the rf modulater */
                                                                   )
{
        return b_ok;
}


bdecode_window_t bdecode_window_open(
                                   bobject_t window_id, /* window's object id */
                                   bdisplay_t display /* display on which the window appears */
                                   )
{
        return (bdecode_window_t)1;
}

void bdecode_window_close(
                                        bdecode_window_t window
                                        )
{
}

bresult bdecode_window_get(
                                          bdecode_window_t window,
                                          bdecode_window_settings *settings       /* [out] */
                                          )
{
        return b_ok;
}

bresult bdecode_window_set(
                                          bdecode_window_t window,
                                          bdecode_window_settings *settings
                                          )
{
        return b_ok;
}
        
bresult bdecode_window_preset(
                                         bdecode_window_t window,
                                         bdecode_window_settings *settings
                                     )
{
        return b_ok;
}


int b_lock_vdc(void)
{
}

void b_unlock_vdc(void)
{
}

bresult bdisplay_set_vbi_rating_info(
                                                        bdisplay_t display, unsigned int ratings_tv, unsigned int ratings_movie,
                                                        unsigned int content_v, unsigned int content_s, unsigned int content_l, unsigned int content_d
                                                        )
{
        return b_ok;
}

bresult bdisplay_output_rf_enable(
                                                                 bdisplay_t display, /* handle returned by bdisplay_open */
                                                                 bool enable
                                                                 )
{
        return b_ok;
}


/**
Summary:
enable deinterlacer on display (id), and disable deinterlacer on other display (!id)
**/
void bdisplay_set_deinterlacer(bdisplay_t display, int id, bool enable)
{
}
void bdisplay_set_coefficient_index(bdisplay_t display,bool horiz, int output, int coeff_idx)
{
}

bresult bdisplay_output_hdmi_enable(bdisplay_t display, bool enable)
{
        return b_ok;
}
bresult bdisplay_set_init_format(bobject_t display_id, bsettop_display_format_t fmt)
{
        return b_ok;
}
void bdisplay_get_default_settings(bdisplay_settings *psettings)
{
}

bresult bsettop_init(bsettop_version version)
{
}
bresult smessage_init(void *decode_cfgs)
{
        return b_ok;
}
bresult bsettop_hdmi_open(
                                        bsettop_hdmi_t *h_hdmi,
                                        bdisplay_t display,     /* display on which the graphics are displayed */
                                        baudio_decode_t audio_decode,
                                        bsettop_hdcp_authentication_cb_t hdcp_authentication_cb
                                        )
{
        return b_ok;
}
void bsettop_hdmi_close(bsettop_hdmi_t h_hdmi)
{
}
bresult boutput_hdmi_get_status(bsettop_hdmi_t h_hdmi,
                                boutput_hdmi_status *status /* [out] */
                                     )
{
        return b_ok;
}

brfm_t brfm_open(
                                         bobject_t rfm_id       /* - index used to identify a particular rfm */
                                        )
{
        return (brfm_t)1;
}

/*
Summary:
        Close the rfm.
*/
void brfm_close(
                                  brfm_t rfm    /* - handle returned by brfm_open */
                                 )
{
}

int chm_process_mss(void *p_chm,               /* Channel manager reference */
                const uint8_t* p_mms,          /* Pointer to MMS */
                unsigned char* mms_buf,         /* string buffer */
                unsigned int mms_len            /* string buffer length */
                )
{
        return 0;
}
void chm_init(void *p_chm, void *p_app)
{
}

/*
Summary:
Function to pass a command to the channel manager.
Any results and notification is handled by passing events to the app via
the msg_queue.

 */
void chm_cmd(void *p_chm,void *p_cmd_evt)
{
}

#if 0
void factory_draw(void *v_app, void *v_screen)
{
}

int factory_handle_event(void *v_app, void *v_screen, void *p_event)
{
        return 0;
}
#endif
void image_get_status(void* st)
{
}
        /* Jan 1, 1970 => Thursday */
        #define START_DAY       3
        #define START_YEAR 1970
/* Days/month for non-leap year */
const unsigned char s_days_per_mon[] = 
{
        31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
        31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31,
};

#define IS_LEAP_YEAR(y) ( !((y + START_YEAR) % 4) && ( ((y + START_YEAR) % 100) || !((y + START_YEAR) % 400) ) )
void utctime(unsigned int secs,b_tm *p_tm)
{
        unsigned int yday,mon,t_val;
        unsigned char *p_dpm = (unsigned char*)s_days_per_mon;

        memset(p_tm,0,sizeof(b_tm));

        /* seconds */
        p_tm->tm_sec = secs % 60;
        t_val = secs / 60;  /* minutes */

        /* minutes */
        p_tm->tm_min = t_val % 60;
        t_val /= 60; /* hours */

        /* hours */
        p_tm->tm_hour = t_val % 24;
        t_val /= 24;

        /* day of week */
    p_tm->tm_wday = t_val % 7;
    p_tm->tm_wday = (t_val - START_DAY) % 7;

        /* offset value to start of the year */
#ifndef LINUX
        t_val += 5;
#endif
        /* year */
    p_tm->tm_yday = t_val;
    p_tm->tm_year = 0;

    /* day of current year */
    while ((IS_LEAP_YEAR(p_tm->tm_year) && (p_tm->tm_yday > 365)) ||
            (!IS_LEAP_YEAR(p_tm->tm_year) && (p_tm->tm_yday > 364)))
    {
        if (IS_LEAP_YEAR(p_tm->tm_year))
            p_tm->tm_yday -= 366;
        else
            p_tm->tm_yday -= 365;
        p_tm->tm_year++;
    }

        if (IS_LEAP_YEAR(p_tm->tm_year))
                p_dpm += 12;

        yday = p_tm->tm_yday + 1;
        mon = 0;
    while(yday > p_dpm[mon])
    {
        yday -= p_dpm[mon];
                mon++;
        }

        /* month */
        p_tm->tm_mon = mon;

        /* day of month */
        p_tm->tm_mday = yday;

}

bool is_video_format_supported()
{
        return true;
}
bool bsettop_hdmi_is_video_fmt_supported(bsettop_display_format_t fmt)
{
        return true;
}
void *image_get_header(int bank, bool *bact)
{
        return NULL;
}

bool bsettop_hdmi_get_RGB_output(void)
{
        return true;
}

bresult bsettop_hdmi_set_RGB_output(bool bRGB)
{
        return b_ok;
}
bool bsettop_hdmi_get_native_audio_mode(void)
{
        return true;
}
BERR_Code bsettop_hdmi_set_native_audio_mode(bool native)
{
        return BERR_SUCCESS;
}


bool g_disable_fcc;
uint32_t ui32OutputChannelMatrix[1][1];
void bsettop_uninit(void)
{
}

btuner_t btuner_open(
                                         bobject_t tuner_id     /* - handle used to identify a particular tuner */
                                        )
{
        return (btuner_t)1;
}

/*
Summary:
        Close a tuner.
*/
void btuner_close(
                                  btuner_t tuner        /* - handle returned by btuner_open */
                                 )
{
}
bresult btuner_get_softdecisions(
        btuner_t tuner, 
        btuner_softdecision_t *pdec,    /* - [out] array of soft decisions */
        size_t length                                   /* number of soft decisions to get */
        )
{
        return b_ok;
}
bband_t btuner_tune(
        btuner_t tuner,
        unsigned freq,  /* - RF center frequency in Hz */
        btuner_params *params    /* - parameters needed to tune and acquire */
        )
{
        return (bband_t)1;
}
bresult btuner_get_status(
        btuner_t tuner,
        btuner_status *status   /* - [out] Current status of the SDS demod */
        )
{
        return b_ok;
}

bresult btuner_reset_status(btuner_t tuner)
{
        return b_ok;
}
void btuner_params_init(
        btuner_params *ds,      /* - [out] */
        btuner_t tuner                          /* - required for possible resource-dependent defaults */
        )
{
}

int chm_get_hunt_progress(void *p_chm)
{
        return 50;
}
int chm_get_cdl_progress(void *p_chm)
{
        return 50;
}
bool chm_is_chmap_updated(void *p_chm)
{
        return true;
}
bresult bspi_identify(
                                          bspi_settings_t *p_settings   /* [out] SPI flash settings structure */
                                          )
{
        p_settings->se_cmd = 0xD8;
        p_settings->sector_size = 0x10000;
        p_settings->page_size = 0x100;
        return b_ok;
}

int chm_get_time_info(void *p_chm, 
                                          unsigned int *utc_secs,                       /* Current UTC time in seconds */
                                          int *local_offset,                            /* Local time offset from UTC time in seconds */
                                          bool *dst                                                     /* Daylight savings flag */
                                         )
{
        return -1;
}

void bsettop_pvt()
{
}