atmo.cpp

VLC Player Source Code

        now we have to read a lof of options from the config dialog
        most important the serial device if not set ... we can skip
        the rest and disable the filter...
        */
        char *psz_serialdev = var_CreateGetStringCommand( p_filter,
                                                      CFG_PREFIX "serialdev" );
        if(psz_serialdev && (strlen(psz_serialdev)>0)) {
            msg_Dbg( p_filter, "use buildin driver on port %s",psz_serialdev);

            p_sys->p_atmo_config = new CAtmoConfig();

            p_sys->p_atmo_config->setSerialDevice(psz_serialdev);

            p_sys->p_atmo_config->setLiveViewFilterMode(
                (AtmoFilterMode)var_CreateGetIntegerCommand( p_filter,
                                                       CFG_PREFIX "filtermode")
                );

            p_sys->p_atmo_config->setLiveViewFilter_PercentNew(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "PercentNew")
                );
            p_sys->p_atmo_config->setLiveViewFilter_MeanLength(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "MeanLength")
                );
            p_sys->p_atmo_config->setLiveViewFilter_MeanThreshold(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "MeanThreshold")
                );

            p_sys->p_atmo_config->setLiveView_EdgeWeighting(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "EdgeWeightning")
                );
            p_sys->p_atmo_config->setLiveView_BrightCorrect(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "Brightness")
                );
            p_sys->p_atmo_config->setLiveView_DarknessLimit(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "DarknessLimit")
                );
            p_sys->p_atmo_config->setLiveView_HueWinSize(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "HueWinSize")
                );
            p_sys->p_atmo_config->setLiveView_SatWinSize(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "SatWinSize")
                );

            /* currently not required inside vlc */
            p_sys->p_atmo_config->setLiveView_WidescreenMode( 0 );

            p_sys->p_atmo_config->setLiveView_FrameDelay(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "FrameDelay")
                );


            p_sys->p_atmo_config->setUseSoftwareWhiteAdj(
                var_CreateGetBoolCommand( p_filter, CFG_PREFIX "whiteadj")
                );
            p_sys->p_atmo_config->setWhiteAdjustment_Red(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-red")
                );
            p_sys->p_atmo_config->setWhiteAdjustment_Green(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-green")
                );
            p_sys->p_atmo_config->setWhiteAdjustment_Blue(
                var_CreateGetIntegerCommand( p_filter, CFG_PREFIX "white-blue")
                );

            tChannelAssignment *p_channel_assignment =
                                 p_sys->p_atmo_config->getChannelAssignment(0);

            p_channel_assignment->mappings[0] = var_CreateGetIntegerCommand(
                                             p_filter, CFG_PREFIX "channel_0");

            p_channel_assignment->mappings[1] = var_CreateGetIntegerCommand(
                                             p_filter, CFG_PREFIX "channel_1");

            p_channel_assignment->mappings[2] = var_CreateGetIntegerCommand(
                                             p_filter, CFG_PREFIX "channel_2");

            p_channel_assignment->mappings[3] = var_CreateGetIntegerCommand(
                                             p_filter, CFG_PREFIX "channel_3");

            p_channel_assignment->mappings[4] = var_CreateGetIntegerCommand(
                                             p_filter, CFG_PREFIX "channel_4");

            for(int i=0;i<ATMO_NUM_CHANNELS;i++)
                msg_Dbg( p_filter, "map software channel %d to hardware channel %d",
                p_channel_assignment->mappings[i],
                i
                );

            // gradient_zone_0
            char psz_gradient_var_name[30];
            char *psz_gradient_file;
            for(int i=0;i<ATMO_NUM_CHANNELS;i++)
            {
                sprintf(psz_gradient_var_name, CFG_PREFIX "gradient_zone_%d", i);
                psz_gradient_file = var_CreateGetStringCommand(
                    p_filter,
                    psz_gradient_var_name
                    );
                if(psz_gradient_file && strlen(psz_gradient_file)>0)
                {
                    msg_Dbg( p_filter, "loading gradientfile %s for "\
                                       "zone %d", psz_gradient_file, i);

                    int i_res = p_sys->p_atmo_config->getZoneDefinition(i)->
                                LoadGradientFromBitmap(psz_gradient_file);

                    if(i_res != ATMO_LOAD_GRADIENT_OK)
                    {
                        msg_Err( p_filter,"failed to load gradient '%s' with "\
                                          "error %d",psz_gradient_file,i_res);
                    }
                }
                free( psz_gradient_file );
            }

            p_sys->p_atmo_dyndata = new CAtmoDynData((vlc_object_t *)p_filter,
                p_sys->p_atmo_config
                );

            msg_Dbg( p_filter, "buildin driver initialized");

            free(psz_serialdev);
        } else {
            msg_Err(p_filter,"no serial devicename set");
        }
    }

    switch( p_filter->fmt_in.video.i_chroma )
    {
    case VLC_FOURCC('I','4','2','0'):
    case VLC_FOURCC('I','Y','U','V'):
    case VLC_FOURCC('Y','V','1','2'):
    case VLC_FOURCC('Y','V','1','6'):
    case VLC_FOURCC('Y','V','U','9'):
        // simple enough? Dionoea?
        p_sys->pf_extract_mini_image = ExtractMiniImage_YUV;
        break;
    default:
        msg_Dbg( p_filter, "InitFilter-unsupported chroma: %4.4s",
                            (char *)&p_filter->fmt_in.video.i_chroma);
        p_sys->pf_extract_mini_image = NULL;
    }

    p_sys->i_crop_x_offset  = 0;
    p_sys->i_crop_y_offset  = 0;
    p_sys->i_crop_width     = p_filter->fmt_in.video.i_visible_width;
    p_sys->i_crop_height    = p_filter->fmt_in.video.i_visible_height;

    msg_Dbg( p_filter, "set default crop %d,%d %dx%d",p_sys->i_crop_x_offset,
        p_sys->i_crop_y_offset,
        p_sys->i_crop_width,
        p_sys->i_crop_height );


#if defined(__ATMO_DEBUG__)
    /* save debug images to a folder as Bitmap files ? */
    p_sys->b_saveframes  = var_CreateGetBoolCommand( p_filter,
        CFG_PREFIX "saveframes"
        );
    msg_Dbg(p_filter,"saveframes = %d", (int)p_sys->b_saveframes);

    /*
    read debug image folder from config
    */
    psz_path = var_CreateGetStringCommand( p_filter, CFG_PREFIX "framepath" );
    if(psz_path != NULL)
    {
        strcpy(p_sys->sz_framepath, psz_path);
#if defined( WIN32 )
        size_t i_strlen = strlen(p_sys->sz_framepath);
        if((i_strlen>0) && (p_sys->sz_framepath[i_strlen-1] != '\\'))
        {
            p_sys->sz_framepath[i_strlen] = '\\';
            p_sys->sz_framepath[i_strlen+1] = 0;
        }
#endif
        free(psz_path);
    }
    msg_Dbg(p_filter,"saveframesfolder %s",p_sys->sz_framepath);
#endif

    /*
       size of extracted image by default 64x48 (other imagesizes are
       currently ignored by AtmoWin)
    */
    p_sys->i_atmo_width  = var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "width");
    p_sys->i_atmo_height = var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "height");
    msg_Dbg(p_filter,"mini image size %d * %d pixels", p_sys->i_atmo_width,
        p_sys->i_atmo_height);

    /*
    because atmowin could also be used for lighten up the room - I think if you
    pause the video it would be useful to get a little bit more light into to
    your living room? - instead switching on a lamp?
    */
    p_sys->b_usepausecolor = var_CreateGetBoolCommand( p_filter,
        CFG_PREFIX "usepausecolor" );
    p_sys->ui_pausecolor_red = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "pcolor-red");
    p_sys->ui_pausecolor_green = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "pcolor-green");
    p_sys->ui_pausecolor_blue = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "pcolor-blue");
    p_sys->i_fadesteps = var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "fadesteps");
    if(p_sys->i_fadesteps < 1)
        p_sys->i_fadesteps = 1;
    msg_Dbg(p_filter,"use pause color %d, RGB: %d, %d, %d, Fadesteps: %d",
        (int)p_sys->b_usepausecolor,
        p_sys->ui_pausecolor_red,
        p_sys->ui_pausecolor_green,
        p_sys->ui_pausecolor_blue,
        p_sys->i_fadesteps);

    /*
    this color is use on shutdown of the filter - the define the
    final light after playback... may be used to dim up the light -
    how it happens in the cinema...
    */
    p_sys->ui_endcolor_red = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "ecolor-red");
    p_sys->ui_endcolor_green = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "ecolor-green");
    p_sys->ui_endcolor_blue = (uint8_t)var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "ecolor-blue");
    p_sys->i_endfadesteps = var_CreateGetIntegerCommand( p_filter,
        CFG_PREFIX "efadesteps");
    if(p_sys->i_endfadesteps < 1)
        p_sys->i_endfadesteps = 1;
    msg_Dbg(p_filter,"use ende color RGB: %d, %d, %d, Fadesteps: %d",
        p_sys->ui_endcolor_red,
        p_sys->ui_endcolor_green,
        p_sys->ui_endcolor_blue,
        p_sys->i_endfadesteps);

    /* if the external DLL was loaded successfully call AtmoInitialize -
    (must be done for each thread where you wan't to use AtmoLight!
    */
    int i = AtmoInitialize(p_filter, false);
#if defined( WIN32 )
    if((i != 1) && !b_use_buildin_driver)
    {
        /* COM Server for AtmoLight not running ?
        if the exe path is configured try to start the "userspace" driver
        */
        psz_path = var_CreateGetStringCommand( p_filter,
                                               CFG_PREFIX "atmowinexe" );
        if(psz_path != NULL)
        {
            STARTUPINFO startupinfo;
            PROCESS_INFORMATION pinfo;
            memset(&startupinfo, 0, sizeof(STARTUPINFO));
            startupinfo.cb = sizeof(STARTUPINFO);
            if(CreateProcess(psz_path, NULL, NULL, NULL,
                FALSE, 0, NULL, NULL, &startupinfo, &pinfo) == TRUE)
            {
                msg_Dbg(p_filter,"launched AtmoWin from %s",psz_path);
                WaitForInputIdle(pinfo.hProcess, 5000);
                /*
                retry to initialize the library COM ... functionality
                after the server was launched
                */
                i = AtmoInitialize(p_filter, false);
            } else {
                msg_Err(p_filter,"failed to launch AtmoWin from %s", psz_path);
            }
            free(psz_path);
        }
    }
#endif

    if(i == 1) /* Init Atmolight success... */
    {
        msg_Dbg( p_filter, "AtmoInitialize Ok!");

        /* Setup Transferbuffers for 64 x 48 , RGB with 32bit Per Pixel */
        AtmoCreateTransferBuffers(p_filter, BI_RGB, 4,
            p_sys->i_atmo_width,
            p_sys->i_atmo_height
            );

        /* say the userspace driver that a live mode should be activated
        the functions returns the old mode for later restore!
        */
        p_sys->i_AtmoOldEffect = AtmoSwitchEffect(p_filter, emLivePicture);

        /*
        live view can have two differnt source the AtmoWinA
        internal GDI Screencapture and the external one - which we
        need here...
        */
        AtmoSetLiveSource(p_filter, lvsExternal);

        /* enable other parts only if everything is fine */
        p_sys->b_enabled = true;
    }

}


/*****************************************************************************
* CreateFilter: allocates AtmoLight video thread output method
*****************************************************************************
* This function allocates and initializes a AtmoLight vout method.
*****************************************************************************/
static int CreateFilter( vlc_object_t *p_this )
{
    filter_t *p_filter = (filter_t *)p_this;
    filter_sys_t *p_sys;

    /* Allocate structure */
    p_sys = (filter_sys_t *)malloc( sizeof( filter_sys_t ) );
    p_filter->p_sys = p_sys;
    if( p_filter->p_sys == NULL )
        return VLC_ENOMEM;
    /* set all entries to zero */
    memset(p_sys, 0, sizeof( filter_sys_t ));

    /* further Setup Function pointers for videolan for calling my filter */
    p_filter->pf_video_filter = Filter;

    config_ChainParse( p_filter, CFG_PREFIX, ppsz_filter_options,
                       p_filter->p_cfg );

    AddStateVariableCallback(p_filter);

    AddCropVariableCallback(p_filter);

    AddAtmoSettingsVariablesCallbacks(p_filter);

    Atmo_SetupParameters(p_filter);


    return VLC_SUCCESS;
}



/*****************************************************************************
* DestroyFilter: destroy AtmoLight video thread output method
*****************************************************************************
* Terminate an output method created by CreateFilter
*****************************************************************************/

static void DestroyFilter( vlc_object_t *p_this )
{
    filter_t *p_filter = (filter_t *)p_this;
    filter_sys_t *p_sys =  p_filter->p_sys;

    DelStateVariableCallback(p_filter);
    DelCropVariableCallback(p_filter);
    DelAtmoSettingsVariablesCallbacks(p_filter);