config.c.svn-base

H.264 source codes

/*****************************************************************************
 * config.c: vfw x264 encoder
 *****************************************************************************
 * Copyright (C) 2003 Laurent Aimar
 * $Id: config.c,v 1.1 2004/06/03 19:27:09 fenrir Exp $
 *
 * Authors: Justin Clay
 *          Laurent Aimar <[e-mail]>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
 *****************************************************************************/

/**************************************************************************
 *
 *  History:
 *
 *  2004.05.14  CBR encode mode support
 *
 **************************************************************************/

#include "x264vfw.h"
#include <stdio.h>  /* sprintf */
#include <commctrl.h>

#ifdef _MSC_VER
#define X264_VERSION ""
#else
#include "config.h"
#endif

/* Registry */
#define X264_REG_KEY    HKEY_CURRENT_USER
#define X264_REG_PARENT "Software\\GNU"
#define X264_REG_CHILD  "x264"
#define X264_REG_CLASS  "config"

/* window controls */
#define BITRATE_MAX        5000
#define QUANT_MAX        51

/* description */
#define X264_NAME        "x264"
#define X264_DEF_TEXT    "Are you sure you want to load default values?"

/* Registery handling */
typedef struct
{
    char *reg_value;
    int  *config_int;
    int  default_int;
} reg_int_t;

typedef struct
{
    char *reg_value;
    char *config_str;
    char *default_str;
    int max_len;  /* maximum string length, including the terminating NULL char */
} reg_str_t;

CONFIG reg;
static const reg_int_t reg_int_table[] =
{
    /* Main dialog */
    { "bitrate",        &reg.bitrate,           800 },
    { "quantizer",      &reg.i_qp,              26 },
    { "encoding_type",  &reg.i_encoding_type,   1 },
    { "passbitrate",    &reg.i_2passbitrate,    800 },
    { "pass_number",    &reg.i_pass,            1 },
    { "fast1pass",      &reg.b_fast1pass,       1 },
    { "updatestats",    &reg.b_updatestats,     1 },

    /* Advance dialog */
    { "cabac",          &reg.b_cabac,           1 },
    { "loop_filter",    &reg.b_filter,          1 },
    { "keyint_max",     &reg.i_keyint_max,      250 },
    { "keyint_min",     &reg.i_keyint_min,      25 },
    { "refmax",         &reg.i_refmax,          1 },
    { "bmax",           &reg.i_bframe,          2 },
    { "direct_pred",    &reg.i_direct_mv_pred,  1 },
    { "b_refs",         &reg.b_b_refs,          0 },
    { "b_wpred",        &reg.b_b_wpred,         1 },
    { "inloop_a",       &reg.i_inloop_a,        0 },
    { "key_boost",      &reg.i_key_boost,       40 },
    { "b_red",          &reg.i_b_red,           30 },
    { "curve_comp",     &reg.i_curve_comp,      60 },

    /* analysis */
    { "i4x4",           &reg.b_i4x4,            1 },
    { "psub16x16",      &reg.b_psub16x16,       1 },
    { "psub8x8",        &reg.b_psub8x8,         1 },
    { "bsub16x16",      &reg.b_bsub16x16,       1 },
    { "subpel",         &reg.i_subpel_refine,   4 }

};

static const reg_str_t reg_str_table[] =
{
    { "fourcc",         reg.fcc,         "H264",                5 },
    { "statsfile",      reg.stats,       ".\\x264.stats",       MAX_PATH-4 } // -4 because we add pass number
};

void config_reg_load( CONFIG *config )
{
    HKEY    hKey;
    DWORD   i_size;
    int     i;

    RegOpenKeyEx( X264_REG_KEY, X264_REG_PARENT "\\" X264_REG_CHILD,
                  0, KEY_READ, &hKey );

    /* Read all integers */
    for( i = 0; i < sizeof( reg_int_table )/sizeof( reg_int_t); i++ )
    {
        i_size = sizeof( int );
        if( RegQueryValueEx( hKey, reg_int_table[i].reg_value, 0, 0,
                             (LPBYTE)reg_int_table[i].config_int,
                             &i_size ) != ERROR_SUCCESS )
            *reg_int_table[i].config_int = reg_int_table[i].default_int;
    }

    /* Read strings */
    for( i = 0; i < sizeof( reg_str_table )/sizeof( reg_str_t); i++ )
    {
        i_size = reg_str_table[i].max_len;
        if( RegQueryValueEx( hKey, reg_str_table[i].reg_value, 0, 0,
                             (LPBYTE)reg_str_table[i].config_str,
                             &i_size ) != ERROR_SUCCESS )
            lstrcpy( reg_str_table[i].config_str,
                     reg_str_table[i].default_str );
    }

    RegCloseKey( hKey );

    memcpy( config, &reg, sizeof( CONFIG ) );
}

void config_reg_save( CONFIG *config )
{
    HKEY    hKey;
    DWORD   i_size;
    int     i;

    if( RegCreateKeyEx( X264_REG_KEY,
                        X264_REG_PARENT "\\" X264_REG_CHILD,
                        0,
                        X264_REG_CLASS,
                        REG_OPTION_NON_VOLATILE,
                        KEY_WRITE,
                        0, &hKey, &i_size ) != ERROR_SUCCESS )
        return;

    memcpy( &reg, config, sizeof( CONFIG ) );

    /* Save all integers */
    for( i = 0; i < sizeof( reg_int_table )/sizeof( reg_int_t); i++ )
    {
        RegSetValueEx( hKey, reg_int_table[i].reg_value, 0, REG_DWORD,
                       (LPBYTE)reg_int_table[i].config_int, sizeof( int ) );
    }

    /* Save strings */
    for( i = 0; i < sizeof( reg_str_table )/sizeof( reg_str_t); i++ )
    {
        RegSetValueEx( hKey, reg_str_table[i].reg_value, 0, REG_SZ,
                       (LPBYTE)reg_str_table[i].config_str,
                        lstrlen(reg_str_table[i].config_str)+1 );
    }

    RegCloseKey( hKey );
}

/* config_reg_defaults: */
void config_reg_defaults( CONFIG *config )
{
    HKEY hKey;

    if(RegOpenKeyEx( X264_REG_KEY, X264_REG_PARENT, 0, KEY_ALL_ACCESS, &hKey )) {
        return;
    }
    if( RegDeleteKey( hKey, X264_REG_CHILD ) ) {
        return;
    }
    RegCloseKey( hKey );

    /* Just in case */
    memset( config, 0, sizeof( CONFIG ) );

    config_reg_load( config );
    config_reg_save( config );
}

/* Enables or Disables Window Elements based on Selection
 */
static void main_enable_item( HWND hDlg, CONFIG * config )
{
    switch( config->i_encoding_type )
    {
    case 0 : /* 1 Pass, Bitrate Based */
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATEEDIT ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATESLIDER ), TRUE );

        EnableWindow( GetDlgItem( hDlg, IDC_QUANTEDIT ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_QUANTSLIDER ), FALSE );

        EnableWindow( GetDlgItem( hDlg, IDC_2PASS1 ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASS2 ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE_S ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_FAST1PASS ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_UPDATESTATS ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE_BROWSE ), FALSE );
        break;

    case 1 : /* 1 Pass, Quantizer Based */
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATEEDIT ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATESLIDER ), FALSE );

        EnableWindow( GetDlgItem( hDlg, IDC_QUANTEDIT ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_QUANTSLIDER ), TRUE );

        EnableWindow( GetDlgItem( hDlg, IDC_2PASS1 ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASS2 ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE_S ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_FAST1PASS ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_UPDATESTATS ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE_BROWSE ), FALSE );
        break;
    
    case 2 : /* 2 Pass */
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATEEDIT ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_BITRATESLIDER ), FALSE );

        EnableWindow( GetDlgItem( hDlg, IDC_QUANTEDIT ), FALSE );
        EnableWindow( GetDlgItem( hDlg, IDC_QUANTSLIDER ), FALSE );

        EnableWindow( GetDlgItem( hDlg, IDC_2PASS1 ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASS2 ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE_S ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_FAST1PASS ), config->i_pass == 1);
        EnableWindow( GetDlgItem( hDlg, IDC_UPDATESTATS ), config->i_pass > 1 );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE ), config->i_pass == 1 );
        EnableWindow( GetDlgItem( hDlg, IDC_STATSFILE_BROWSE ), config->i_pass == 1 );
        break;
    }

    SendDlgItemMessage( hDlg, IDC_BITRATESLIDER, TBM_SETRANGE, TRUE,
                        (LPARAM) MAKELONG( 0, BITRATE_MAX ) );
    SendDlgItemMessage( hDlg, IDC_QUANTSLIDER, TBM_SETRANGE, TRUE,
                        (LPARAM) MAKELONG( 0, QUANT_MAX ) );
    SendDlgItemMessage( hDlg, IDC_2PASSBITRATE_S, TBM_SETRANGE, TRUE,
                        (LPARAM) MAKELONG( 0, BITRATE_MAX ) );

}

/* Updates the window from config */
static void main_update_dlg( HWND hDlg, CONFIG * config )
{
    SetDlgItemInt( hDlg, IDC_BITRATEEDIT, config->bitrate, FALSE );
    SetDlgItemInt( hDlg, IDC_QUANTEDIT, config->i_qp, FALSE );
    SetDlgItemInt( hDlg, IDC_2PASSBITRATE, config->i_2passbitrate, FALSE );
    SetDlgItemText( hDlg, IDC_STATSFILE, config->stats );

    switch( config->i_encoding_type )
    {
    case 0 : /* 1 Pass, Bitrate Based */
        CheckRadioButton( hDlg,
                          IDC_RADIOBITRATE, IDC_RADIOTWOPASS, IDC_RADIOBITRATE);
        break;
    case 1 : /* 1 Pass, Quantizer Based */
        CheckRadioButton( hDlg,
                          IDC_RADIOBITRATE, IDC_RADIOTWOPASS, IDC_RADIOQUANT);
            break;
    case 2 : /* 2 Pass */
        CheckRadioButton( hDlg,
                          IDC_RADIOBITRATE, IDC_RADIOTWOPASS, IDC_RADIOTWOPASS);

        if (config->i_pass == 1)
            CheckRadioButton(hDlg,
                             IDC_2PASS1, IDC_2PASS2, IDC_2PASS1);
        else 
            CheckRadioButton(hDlg,
                             IDC_2PASS1, IDC_2PASS2, IDC_2PASS2);
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE ), TRUE );
        EnableWindow( GetDlgItem( hDlg, IDC_2PASSBITRATE_S ), TRUE );

        break;
    }

    SendDlgItemMessage( hDlg, IDC_BITRATESLIDER, TBM_SETPOS, TRUE,
                        config->bitrate );
    SendDlgItemMessage( hDlg, IDC_QUANTSLIDER, TBM_SETPOS, TRUE,
                        config->i_qp );
    SendDlgItemMessage( hDlg, IDC_2PASSBITRATE_S, TBM_SETPOS, TRUE,
                        config->i_2passbitrate );
    CheckDlgButton( hDlg, IDC_FAST1PASS, config->b_fast1pass ? BST_CHECKED : BST_UNCHECKED );
    CheckDlgButton( hDlg, IDC_UPDATESTATS, config->b_updatestats ? BST_CHECKED : BST_UNCHECKED );

}


/* Main config dialog */
BOOL CALLBACK callback_main( HWND hDlg, UINT uMsg, WPARAM wParam, LPARAM lParam )
{
    CONFIG* config = (CONFIG*)GetWindowLong(hDlg, GWL_USERDATA);

    switch( uMsg )
    {
    case WM_INITDIALOG :
        SetWindowLong( hDlg, GWL_USERDATA, lParam );
        config = (CONFIG*)lParam;

        main_enable_item( hDlg, config );
        main_update_dlg( hDlg, config );

        break;

    case WM_COMMAND:
        switch ( HIWORD( wParam ) )
        {
        case BN_CLICKED :
            switch( LOWORD( wParam ) )
            {
            case IDOK :
                config->b_save = TRUE;
			    EndDialog( hDlg, LOWORD(wParam) );
                break;
            case IDCANCEL :
                config->b_save = FALSE;
                EndDialog( hDlg, LOWORD(wParam) );
                break;
            case IDC_ADVANCED :
                DialogBoxParam( g_hInst, MAKEINTRESOURCE(IDD_ADVANCED),
                                (HWND)lParam, callback_advanced,
                                (LPARAM)config );
                break;
            case IDC_DEFAULTS :
                if( MessageBox( hDlg, X264_DEF_TEXT, X264_NAME, MB_YESNO ) == IDYES )
                {
                    config_reg_defaults( config );
                    main_enable_item( hDlg, config );
                    main_update_dlg( hDlg, config );
                }
                break;
            case IDC_RADIOBITRATE :
                config->i_encoding_type = 0; /* 1 Pass, Bitrate Mode=0 */
                main_enable_item( hDlg, config );
                main_update_dlg( hDlg, config );
                break;
            case IDC_RADIOQUANT :
                config->i_encoding_type = 1; /* 1 Pass, Quantizer Mode=1 */
                main_enable_item( hDlg, config );
                main_update_dlg( hDlg, config );
                break;
            case IDC_RADIOTWOPASS :
                config->i_encoding_type = 2; /* 2 Pass Mode=2 */
                main_enable_item( hDlg,  config );
                main_update_dlg( hDlg, config );
                break;
            case IDC_2PASS1 :
                config->i_pass = 1; /* 1st pass */
                main_enable_item( hDlg,  config );
                main_update_dlg( hDlg, config );
                break;
            case IDC_2PASS2 :
                config->i_pass = 2; /* 2nd pass */
                main_enable_item( hDlg,  config );
                main_update_dlg( hDlg, config );
                break;
            case IDC_FAST1PASS :
                config->b_fast1pass = ( IsDlgButtonChecked( hDlg, IDC_FAST1PASS ) == BST_CHECKED );
                break;
            case IDC_UPDATESTATS :
                config->b_updatestats = ( IsDlgButtonChecked( hDlg, IDC_UPDATESTATS ) == BST_CHECKED );
                break;
            case IDC_STATSFILE_BROWSE :