Example #1
0
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();

  config_add_schema_item( config , "SET" , true );
  config_add_schema_item( config , "NOTSET" , false );

  {
    config_content_type * content = config_parse( config , config_file , "--" , "INCLUDE" , NULL , CONFIG_UNRECOGNIZED_IGNORE , true );
    test_assert_true( config_content_is_instance( content ));
    test_assert_true(config_content_is_valid( content ));

    test_assert_true( config_content_has_item( content , "SET" ));
    test_assert_false( config_content_has_item( content , "NOTSET" ) );
    test_assert_false( config_content_has_item( content , "UNKNOWN" ) );

    test_assert_true( config_has_schema_item( config , "SET" ));
    test_assert_true( config_has_schema_item( config , "NOTSET" ));
    test_assert_false( config_has_schema_item( config , "UNKNOWN" ));

    config_content_free( content );
  }

  exit(0);
}
Example #2
0
void test_min_realizations_percent(const char * num_realizations_str, const char * min_realizations_str, int min_realizations){
  test_work_area_type * work_area = test_work_area_alloc("test_min_realizations");

  {
    FILE * config_file_stream = util_mkdir_fopen("config_file", "w");
    test_assert_not_NULL(config_file_stream);
    fprintf(config_file_stream, num_realizations_str);
    fprintf(config_file_stream, min_realizations_str);
    fclose(config_file_stream);

    config_type * c = config_alloc();
    config_schema_item_type * item = config_add_schema_item(c , NUM_REALIZATIONS_KEY , true );
    config_schema_item_set_default_type(item, CONFIG_INT);
    config_schema_item_set_argc_minmax( item , 1 , 1);
    item = config_add_schema_item(c , MIN_REALIZATIONS_KEY , false );
    config_schema_item_set_argc_minmax( item , 1 , 2);
    test_assert_true(config_parse(c , "config_file" , "--" , NULL , NULL , false , true ));

    analysis_config_type * ac = create_analysis_config( );
    analysis_config_init(ac, c);

    test_assert_int_equal( min_realizations , analysis_config_get_min_realisations( ac ) );

    analysis_config_free( ac );
    config_free( c );
  }

  test_work_area_free(work_area);
}
Example #3
0
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();
  {
    config_schema_item_type * item  = config_add_schema_item(config , "APPEND" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1);
  }
  config_add_schema_item(config , "NEXT"   , false );

  config_content_type * content = config_parse(config , config_file , "--" , NULL , NULL , NULL , false , true );

  if (config_content_is_valid( content )) {
    if (config_content_get_size( content ) == 4) {
      const config_content_node_type * node0 = config_content_iget_node( content , 0 );
      if (strcmp( config_content_node_get_kw( node0 ) , "APPEND") == 0) {
        if (config_content_node_get_size(node0) == 1) {
          const config_content_node_type * node3 = config_content_iget_node( content , 3 );
          if (strcmp( config_content_node_get_kw( node3 ) , "NEXT") == 0) {
            if (config_content_node_get_size(node3) == 2) {
              config_content_free( content );
              exit(0);
            } else printf("Size error node3\n");
          } else printf("kw error node3 \n");
        } else printf("Size error node0\n");
      } else printf("kw error node0 kw:%s \n", config_content_node_get_kw( node0 ));
    } else printf("Size error \n");
  } else printf("Parse error");

  config_content_free( content );
  exit(1);
}
Example #4
0
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_type * config = config_alloc();
  bool OK;
  {
    config_schema_item_type * item  = config_add_schema_item(config , "TYPE_KEY" , false );
    config_schema_item_set_argc_minmax( item , 4 , 4 );
    config_schema_item_iset_type( item , 0 , CONFIG_INT );
    config_schema_item_iset_type( item , 1 , CONFIG_FLOAT );
    config_schema_item_iset_type( item , 2 , CONFIG_BOOL );

    item = config_add_schema_item( config , "SHORT_KEY" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1 );
    
    item = config_add_schema_item( config , "LONG_KEY" , false );
    config_schema_item_set_argc_minmax( item , 3 , CONFIG_DEFAULT_ARG_MAX );
  }
  OK = config_parse(config , config_file , "--" , NULL , NULL , false , true );
  
  if (OK) {
    
  } else error("Parse error\n");
  
  exit(0);
}
Example #5
0
config_type * config_create_schema() {
  config_type * config = config_alloc();
  
  config_add_schema_item( config , "SET" , true );
  config_add_schema_item( config , "NOTSET" , false );

  return config;
}
Example #6
0
int main(void) {
  const char * config_file = "config_test_input";
  config_type * config = config_alloc();
  config_schema_item_type * item;
  
  item = config_add_schema_item(config , "KEY1" , true  , true);
  item = config_add_schema_item(config , "KEY2" , true  , false);
  config_schema_item_set_argc_minmax(item , 1 , 4 , 4 , (const config_item_types [4]) {CONFIG_EXECUTABLE , CONFIG_EXISTING_FILE , CONFIG_BOOLEAN , CONFIG_BOOLEAN});
Example #7
0
config_type * create_config( ) {
    config_type * config = config_alloc( );
    config_schema_item_type * item;

    item = config_add_schema_item(config , ENSPATH_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 0 , NULL);

    item = config_add_schema_item(config , NUM_REALIZATIONS_KEY , true , false);
    config_schema_item_set_argc_minmax(item , 1 , 1 , 1, (const config_item_types [1]) {
        CONFIG_INT
    });
Example #8
0
void init_core(void) {
	config* config_handle = NULL;
	config_alloc(&config_handle, "config/core.cfg");

	engine_init(config_get_int_value(config_handle, "enable_alarms"));

	global* global_handle = NULL;
	global_alloc(&global_handle);

	config_free(&config_handle);

	global_set(global_handle, GLOBAL_EDITOR_MODE, EDITOR_MODE_OFF);
}
Example #9
0
void test_init(const char * config_file) {
  site_config_type * site_config = site_config_alloc_empty();
  config_type * config = config_alloc();

  site_config_add_config_items( config , true );
  if (!config_parse(config , config_file , "--" , INCLUDE_KEY , DEFINE_KEY , CONFIG_UNRECOGNIZED_WARN , true))
    test_error_exit("Parsing site config file:%s failed \n",config_file );

  if (!site_config_init( site_config , config ))
    test_error_exit("Loading site_config from config failed\n");
  
  config_free( config );
  site_config_free( site_config );
}
Example #10
0
int main(int argc , char ** argv) {
  config_type * config = config_alloc();
  ert_report_list_type * report_list = ert_report_list_alloc( NULL , NULL );

  test_assert_not_NULL( report_list );
  ert_report_list_add_config_items( config );
  test_assert_true( config_parse( config , argv[1] , "--" , NULL, NULL , CONFIG_UNRECOGNIZED_IGNORE , true ));
  ert_report_list_init( report_list , config , NULL);
  
  test_assert_int_equal( 167 , ert_report_list_get_latex_timeout( report_list ));
  test_assert_true( ert_report_list_get_init_large_report( report_list ));

  ert_report_list_free( report_list );
  exit(0);
}
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();
  config_content_type * content;
  ensemble_config_type * ensemble = ensemble_config_alloc();

  enkf_config_node_add_GEN_PARAM_config_schema( config );

  content = config_parse( config , config_file , "--" , NULL , NULL , CONFIG_UNRECOGNIZED_WARN , true );
  test_assert_true( config_content_is_valid( content ) );

  ensemble_config_init_GEN_PARAM( ensemble, content );

  config_content_free( content );
  config_free( config );
  ensemble_config_free( ensemble );
  exit(0);
}
Example #12
0
config_parser_type * workflow_job_alloc_config() {
    config_parser_type * config = config_alloc();
    {
        config_schema_item_type * item;

        item = config_add_schema_item( config , MIN_ARG_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );

        item = config_add_schema_item( config , MAX_ARG_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );

        item = config_add_schema_item( config , ARG_TYPE_KEY , false );
        config_schema_item_set_argc_minmax( item , 2 , 2 );
        config_schema_item_iset_type( item , 0 , CONFIG_INT );
        config_schema_item_set_indexed_selection_set( item , 1 , 4 , (const char *[4]) {
            WORKFLOW_JOB_STRING_TYPE , WORKFLOW_JOB_INT_TYPE , WORKFLOW_JOB_FLOAT_TYPE, WORKFLOW_JOB_BOOL_TYPE
        });

        /*****************************************************************/
        item = config_add_schema_item( config , EXECUTABLE_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_PATH );

        /*****************************************************************/
        item = config_add_schema_item( config , SCRIPT_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1 );
        config_schema_item_iset_type( item , 0 , CONFIG_PATH );

        /*---------------------------------------------------------------*/

        item = config_add_schema_item( config , FUNCTION_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);

        item = config_add_schema_item( config , MODULE_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);
        /*****************************************************************/

        item = config_add_schema_item( config , INTERNAL_KEY , false );
        config_schema_item_set_argc_minmax( item , 1 , 1);
        config_schema_item_iset_type( item , 0 , CONFIG_BOOL);
    }
Example #13
0
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_type * config = config_alloc();
  config_schema_item_type * item = config_add_schema_item(config , "APPEND" , false );
  config_schema_item_set_argc_minmax( item , 1 , 1);

  test_assert_true(config_parse(config , config_file , "--" , NULL , NULL , false , true ));

  {
    test_assert_int_equal( config_get_occurences( config , "APPEND" ) , 3);
    {
      const char * value = config_get_value( config , "APPEND");
      test_assert_string_equal( value , "VALUE3");
    }
  } 

  test_assert_false( config_parse( config , "DoesNotExist" , "--" , NULL , NULL , false , true));
  exit(0);
}
Example #14
0
int main(int argc , char ** argv) {
  const char * config_file = argv[1];
  config_parser_type * config = config_alloc();
  {
    config_schema_item_type * item  = config_add_schema_item(config , "TYPES_KEY" , false );
    config_schema_item_set_argc_minmax( item , 4 , 4 );
    config_schema_item_iset_type( item , 0 , CONFIG_INT );
    config_schema_item_iset_type( item , 1 , CONFIG_FLOAT );
    config_schema_item_iset_type( item , 2 , CONFIG_BOOL );

    item = config_add_schema_item( config , "SHORT_KEY" , false );
    config_schema_item_set_argc_minmax( item , 1 , 1 );

    item = config_add_schema_item( config , "LONG_KEY" , false );
    config_schema_item_set_argc_minmax( item , 3 , CONFIG_DEFAULT_ARG_MAX);
  }

  {
    config_content_type * content = config_parse(config , config_file , "--" , NULL , NULL , false , true );

    if (config_content_is_valid( content )) {
      error("Parse error\n");
    } else {
      const config_error_type * cerror = config_content_get_errors( content );
      if (config_error_count( cerror ) > 0) {
        int i;
        for (i=0; i < config_error_count( cerror ); i++) {
          printf("Error %d: %s \n",i , config_error_iget( cerror , i ));
        }
      }
      test_assert_int_equal( 5 , config_error_count( cerror ));
    }
    config_content_free( content );
  }
  printf("OK \n");
  exit(0);
}
Example #15
0
void init_graphic(void) {
	global* global_handle = global_get_singleton();

	config* config_handle = NULL;
	config_alloc(&config_handle, "config/graphics.cfg");

	int resx = config_get_int_value(config_handle, "resx");
	int resy = config_get_int_value(config_handle, "resy");
	int samples = config_get_int_value(config_handle, "msaa");
	int windowed = config_get_int_value(config_handle, "windowed");
	int vsync = config_get_int_value(config_handle, "vertical_sync");

	config_free(&config_handle);

	window* window_handle = NULL;
	window_alloc(&window_handle, resx, resy, samples, !windowed, vsync, 1);

	window_set_blend_mode(window_handle, WINDOW_BLEND_ALPHA);
	window_set_clear_color(window_handle, 0.0f, 0.0f, 0.0f, 0.0f);

	global_set(global_handle, GLOBAL_WINDOW, window_handle);

	hl_render* hl_render_handle = NULL;
	hl_render_alloc(&hl_render_handle);

	global_set(global_handle, GLOBAL_HL_RENDER, hl_render_handle);

	// effect* effect_motion_blur_handle = NULL;
	// effect_alloc(&effect_motion_blur_handle, effect_motion_blur_init, effect_motion_blur_render, effect_motion_blur_config, effect_motion_blur_free, window_get_width(window_handle), window_get_height(window_handle));
	// hl_render_add_effect(hl_render_handle, effect_motion_blur_handle, WINDOW_BLEND_ALPHA);

	camera* camera_handle = NULL;
	camera_alloc(&camera_handle);

	camera_set_dimension(camera_handle, CAMERA_SIZE * (float) window_get_width(window_handle) / (float) window_get_height(window_handle), CAMERA_SIZE);
	camera_set_position(camera_handle, 0.0f, 0.0f);

	camera_update_matrices(camera_handle);

	global_set(global_handle, GLOBAL_CAMERA, camera_handle);

	shader* shader_texture_handle = NULL;
	shader_alloc(&shader_texture_handle, SHADER_TEXTURE_VS, SHADER_TEXTURE_PS);

	global_set(global_handle, GLOBAL_SHADER_TEXTURE, shader_texture_handle);

	text* text_handle = NULL;
	text_alloc(&text_handle, camera_handle, window_handle);

	global_set(global_handle, GLOBAL_TEXT, text_handle);

	input* input_handle = NULL;
	input_alloc(&input_handle, window_handle);

	global_set(global_handle, GLOBAL_INPUT, input_handle);

	debug_draw* debug_draw_handle = NULL;
	debug_draw_alloc(&debug_draw_handle, hl_render_handle);

	global_set(global_handle, GLOBAL_DEBUG_DRAW, debug_draw_handle);
}
Example #16
0
/**
 * \brief Program main function.
 * \param argc Argument count from commandline
 * \param argv Argument list
 * \return Program exit state
 */
int main(int argc, char *argv[])
{
  config *cfg  = NULL; //!< Global configuration
  FILE *input  = NULL; //!< input file (YUV)
  FILE *output = NULL; //!< output file (HEVC NAL stream)
  encoder_control encoder;
  double psnr[3] = { 0.0, 0.0, 0.0 };
  uint32_t stat_frames = 0;
  uint64_t curpos = 0;
  FILE *recout = NULL; //!< reconstructed YUV output, --debug
  clock_t start_time = clock();
  clock_t encoding_start_cpu_time;
  CLOCK_T encoding_start_real_time;
  
  clock_t encoding_end_cpu_time;
  CLOCK_T encoding_end_real_time;

  // Stdin and stdout need to be binary for input and output to work.
  // Stderr needs to be text mode to convert \n to \r\n in Windows.
  #ifdef _WIN32
      _setmode( _fileno( stdin ),  _O_BINARY );
      _setmode( _fileno( stdout ), _O_BINARY );
      _setmode( _fileno( stderr ), _O_TEXT );
  #endif
      
  CHECKPOINTS_INIT();

  // Handle configuration
  cfg = config_alloc();

  // If problem with configuration, print banner and shutdown
  if (!cfg || !config_init(cfg) || !config_read(cfg,argc,argv)) {
    fprintf(stderr,
            "/***********************************************/\n"
            " *   Kvazaar HEVC Encoder v. " VERSION_STRING "             *\n"
            " *     Tampere University of Technology 2014   *\n"
            "/***********************************************/\n\n");

    fprintf(stderr,
            "Usage:\n"
            "kvazaar -i <input> --input-res <width>x<height> -o <output>\n"
            "\n"
            "Optional parameters:\n"
            "      -n, --frames <integer>     : Number of frames to code [all]\n"
            "      --seek <integer>           : First frame to code [0]\n"
            "      --input-res <int>x<int>    : Input resolution (width x height)\n"
            "      -q, --qp <integer>         : Quantization Parameter [32]\n"
            "      -p, --period <integer>     : Period of intra pictures [0]\n"
            "                                     0: only first picture is intra\n"
            "                                     1: all pictures are intra\n"
            "                                     2-N: every Nth picture is intra\n"
            "      -r, --ref <integer>        : Reference frames, range 1..15 [3]\n"
            "          --no-deblock           : Disable deblocking filter\n"
            "          --deblock <beta:tc>    : Deblocking filter parameters\n"
            "                                   beta and tc range is -6..6 [0:0]\n"
            "          --no-sao               : Disable sample adaptive offset\n"
            "          --no-rdoq              : Disable RDO quantization\n"
            "          --rd <integer>         : Rate-Distortion Optimization level [1]\n"
            "                                     0: no RDO\n"
            "                                     1: estimated RDO\n"
            "                                     2: full RDO\n"
            "          --full-intra-search    : Try all intra modes.\n"
            "          --no-transform-skip    : Disable transform skip\n"
            "          --aud                  : Use access unit delimiters\n"
            "          --cqmfile <string>     : Custom Quantization Matrices from a file\n"
            "          --debug <string>       : Output encoders reconstruction.\n"
            "          --cpuid <integer>      : Disable runtime cpu optimizations with value 0.\n"
            "\n"
            "  Video Usability Information:\n"
            "          --sar <width:height>   : Specify Sample Aspect Ratio\n"
            "          --overscan <string>    : Specify crop overscan setting [\"undef\"]\n"
            "                                     - undef, show, crop\n"
            "          --videoformat <string> : Specify video format [\"undef\"]\n"
            "                                     - component, pal, ntsc, secam, mac, undef\n"
            "          --range <string>       : Specify color range [\"tv\"]\n"
            "                                     - tv, pc\n"
            "          --colorprim <string>   : Specify color primaries [\"undef\"]\n"
            "                                     - undef, bt709, bt470m, bt470bg,\n"
            "                                       smpte170m, smpte240m, film, bt2020\n"
            "          --transfer <string>    : Specify transfer characteristics [\"undef\"]\n"
            "                                     - undef, bt709, bt470m, bt470bg,\n"
            "                                       smpte170m, smpte240m, linear, log100,\n"
            "                                       log316, iec61966-2-4, bt1361e,\n"
            "                                       iec61966-2-1, bt2020-10, bt2020-12\n"
            "          --colormatrix <string> : Specify color matrix setting [\"undef\"]\n"
            "                                     - undef, bt709, fcc, bt470bg, smpte170m,\n"
            "                                       smpte240m, GBR, YCgCo, bt2020nc, bt2020c\n"
            "          --chromaloc <integer>  : Specify chroma sample location (0 to 5) [0]\n"
            "\n"
            "  Parallel processing :\n"
            "          --threads <integer>    : Maximum number of threads to use.\n"
            "                                   Disable threads if set to 0.\n"
            "\n"
            "  Tiles:\n"
            "          --tiles-width-split <string>|u<int> : \n"
            "                                   Specifies a comma separated list of pixel\n"
            "                                   positions of tiles columns separation coordinates.\n"
            "                                   Can also be u followed by and a single int n,\n"
            "                                   in which case it produces columns of uniform width.\n"
            "          --tiles-height-split <string>|u<int> : \n"
            "                                   Specifies a comma separated list of pixel\n"
            "                                   positions of tiles rows separation coordinates.\n"
            "                                   Can also be u followed by and a single int n,\n"
            "                                   in which case it produces rows of uniform height.\n"
            "\n"
            "  Wpp:\n"
            "          --wpp                  : Enable wavefront parallel processing\n"
            "          --owf <integer>        : Enable parallel processing of multiple frames\n"
            "\n"
            "  Slices:\n"
            "          --slice-addresses <string>|u<int>: \n"
            "                                   Specifies a comma separated list of LCU\n"
            "                                   positions in tile scan order of tile separations.\n"
            "                                   Can also be u followed by and a single int n,\n"
            "                                   in which case it produces uniform slice length.\n"
            "\n"
            "  Deprecated parameters: (might be removed at some point)\n"
            "     Use --input-res:\n"
            "       -w, --width               : Width of input in pixels\n"
            "       -h, --height              : Height of input in pixels\n");

    goto exit_failure;
  }

  // Add dimensions to the reconstructions file name.
  if (cfg->debug != NULL) {
    char dim_str[50]; // log10(2^64) < 20, so this should suffice. I hate C.
    size_t left_len, right_len;
    sprintf(dim_str, "_%dx%d.yuv", cfg->width, cfg->height);
    left_len = strlen(cfg->debug);
    right_len = strlen(dim_str);
    cfg->debug = realloc(cfg->debug, left_len + right_len + 1);
    if (!cfg->debug) {
      fprintf(stderr, "realloc failed!\n");
      goto exit_failure;
    }
    strcpy(cfg->debug + left_len, dim_str);
  }

  // Do more validation to make sure the parameters we have make sense.
  if (!config_validate(cfg)) {
    goto exit_failure;
  }

  //Initialize strategies
  if (!strategyselector_init(cfg->cpuid)) {
    fprintf(stderr, "Failed to initialize strategies.\n");
    goto exit_failure;
  }

  // Check if the input file name is a dash, this means stdin
  if (!strcmp(cfg->input, "-")) {
    input = stdin;
  } else {
    // Otherwise we try to open the input file
    input = fopen(cfg->input, "rb");
  }

  // Check that input was opened correctly
  if (input == NULL) {
    fprintf(stderr, "Could not open input file, shutting down!\n");
    goto exit_failure;
  }

  // Open output file and check that it was opened correctly
  output = fopen(cfg->output, "wb");
  if (output == NULL) {
    fprintf(stderr, "Could not open output file, shutting down!\n");
    goto exit_failure;
  }

  if (cfg->debug != NULL) {
    recout = fopen(cfg->debug, "wb");
    if (recout == NULL) {
      fprintf(stderr, "Could not open reconstruction file (%s), shutting down!\n", cfg->debug);
      goto exit_failure;
    }
  }
  
  //Allocate and init exp golomb table
  if (!init_exp_golomb(4096*8)) {
    fprintf(stderr, "Failed to allocate the exp golomb code table, shutting down!\n");
    goto exit_failure;
  }

  if (!encoder_control_init(&encoder, cfg)) {
    goto exit_failure;
  }
  
  // Set output file
  encoder.out.file = output;
  
  // input init (TODO: read from commandline / config)
  encoder.bitdepth = 8;
  encoder.in.video_format = FORMAT_420;
  
  // deblocking filter
  encoder.deblock_enable   = (int8_t)encoder.cfg->deblock_enable;
  encoder.beta_offset_div2 = (int8_t)encoder.cfg->deblock_beta;
  encoder.tc_offset_div2   = (int8_t)encoder.cfg->deblock_tc;
  // SAO
  encoder.sao_enable = (int8_t)encoder.cfg->sao_enable;
  // RDO
  encoder.rdoq_enable = (int8_t)encoder.cfg->rdoq_enable;
  encoder.rdo         = (int8_t)encoder.cfg->rdo;
  encoder.full_intra_search = (int8_t)encoder.cfg->full_intra_search;
  // TR SKIP
  encoder.trskip_enable = (int8_t)encoder.cfg->trskip_enable;
  encoder.tr_depth_intra = (int8_t)encoder.cfg->tr_depth_intra;
  // VUI
  encoder.vui.sar_width   = (int16_t)encoder.cfg->vui.sar_width;
  encoder.vui.sar_height  = (int16_t)encoder.cfg->vui.sar_height;
  encoder.vui.overscan    = encoder.cfg->vui.overscan;
  encoder.vui.videoformat = encoder.cfg->vui.videoformat;
  encoder.vui.fullrange   = encoder.cfg->vui.fullrange;
  encoder.vui.colorprim   = encoder.cfg->vui.colorprim;
  encoder.vui.transfer    = encoder.cfg->vui.transfer;
  encoder.vui.colormatrix = encoder.cfg->vui.colormatrix;
  encoder.vui.chroma_loc  = (int8_t)encoder.cfg->vui.chroma_loc;
  // AUD
  encoder.aud_enable = (int8_t)encoder.cfg->aud_enable;

  encoder.in.file = input;

  fprintf(stderr, "Input: %s, output: %s\n", cfg->input, cfg->output);
  fprintf(stderr, "  Video size: %dx%d (input=%dx%d)\n",
         encoder.in.width, encoder.in.height,
         encoder.in.real_width, encoder.in.real_height);
  
  //Now, do the real stuff
  {
    encoder_state *encoder_states = malloc((encoder.owf + 1) * sizeof(encoder_state));
    if (encoder_states == NULL) {
      fprintf(stderr, "Failed to allocate memory.");
      goto exit_failure;
    }

    int i;
    int current_encoder_state = 0;
    for (i = 0; i <= encoder.owf; ++i) {
      encoder_states[i].encoder_control = &encoder;
      if (i > 0) {
        encoder_states[i].previous_encoder_state = &encoder_states[i-1];
      } else { 
        //i == 0, use last encoder as the previous one
        encoder_states[i].previous_encoder_state = &encoder_states[encoder.owf];
      }
      if (!encoder_state_init(&encoder_states[i], NULL)) {
        goto exit_failure;
      }
      encoder_states[i].global->QP = (int8_t)encoder.cfg->qp;
    }
    
    for (i = 0; i <= encoder.owf; ++i) {
      encoder_state_match_children_of_previous_frame(&encoder_states[i]);
    }
    
    //Initial frame
    encoder_states[current_encoder_state].global->frame    = -1;

    // Only the code that handles conformance window coding needs to know
    // the real dimensions. As a quick fix for broken non-multiple of 8 videos,
    // change the input values here to be the real values. For a real fix
    // encoder.in probably needs to be merged into cfg.
    // The real fix would be: never go dig in cfg
    //cfg->width = encoder.in.width;
    //cfg->height = encoder.in.height;
    
    GET_TIME(&encoding_start_real_time);
    encoding_start_cpu_time = clock();

    // Start coding cycle while data on input and not on the last frame
    while(!cfg->frames || encoder_states[current_encoder_state].global->frame < cfg->frames - 1) {
      // Skip '--seek' frames before input.
      // This block can be moved outside this while loop when there is a
      // mechanism to skip the while loop on error.
      if (encoder_states[current_encoder_state].global->frame == 0 && cfg->seek > 0) {
        int frame_bytes = cfg->width * cfg->height * 3 / 2;
        int error = 0;

        if (!strcmp(cfg->input, "-")) {
          // Input is stdin.
          int i;
          for (i = 0; !error && i < cfg->seek; ++i) {
            error = !read_one_frame(input, &encoder_states[current_encoder_state]);
          }
        } else {
          // input is a file. We hope. Proper detection is OS dependent.
          error = fseek(input, cfg->seek * frame_bytes, SEEK_CUR);
        }
        if (error && !feof(input)) {
          fprintf(stderr, "Failed to seek %d frames.\n", cfg->seek);
          break;
        }
        GET_TIME(&encoding_start_real_time);
        encoding_start_cpu_time = clock();
      }
      
      //Compute stats
      encoder_compute_stats(&encoder_states[current_encoder_state], recout, &stat_frames, psnr);
      
      //Clear encoder
      encoder_next_frame(&encoder_states[current_encoder_state]);
      
      //Abort if enough frames
      if (cfg->frames && encoder_states[current_encoder_state].global->frame >= cfg->frames) {
        //Ignore this frame, which is not valid...
        encoder_states[current_encoder_state].stats_done = 1;
        break;
      }
      
      CHECKPOINT_MARK("read source frame: %d", encoder_states[current_encoder_state].global->frame + cfg->seek);

      // Read one frame from the input
      if (!read_one_frame(input, &encoder_states[current_encoder_state])) {
        if (!feof(input))
          fprintf(stderr, "Failed to read a frame %d\n", encoder_states[current_encoder_state].global->frame);
        
        //Ignore this frame, which is not valid...
        encoder_states[current_encoder_state].stats_done = 1;
        break;
      }

      // The actual coding happens here, after this function we have a coded frame
      encode_one_frame(&encoder_states[current_encoder_state]);
      
      //Switch to the next encoder
      current_encoder_state = (current_encoder_state + 1) % (encoder.owf + 1);
    }
    
    //Compute stats for the remaining encoders
    {
      int first_enc = current_encoder_state;
      do {
        current_encoder_state = (current_encoder_state + 1) % (encoder.owf + 1);
        encoder_compute_stats(&encoder_states[current_encoder_state], recout, &stat_frames, psnr);
      } while (current_encoder_state != first_enc);
    }
    
    GET_TIME(&encoding_end_real_time);
    encoding_end_cpu_time = clock();
    
    threadqueue_flush(encoder.threadqueue);
    
    
    // Coding finished
    fgetpos(output,(fpos_t*)&curpos);

    // Print statistics of the coding
    fprintf(stderr, " Processed %d frames, %10llu bits AVG PSNR: %2.4f %2.4f %2.4f\n", stat_frames, (long long unsigned int) curpos<<3,
          psnr[0] / stat_frames, psnr[1] / stat_frames, psnr[2] / stat_frames);
    fprintf(stderr, " Total CPU time: %.3f s.\n", ((float)(clock() - start_time)) / CLOCKS_PER_SEC);
    
    {
      double encoding_time = ((double)(encoding_end_cpu_time - encoding_start_cpu_time)) / CLOCKS_PER_SEC;
      double wall_time = CLOCK_T_AS_DOUBLE(encoding_end_real_time) - CLOCK_T_AS_DOUBLE(encoding_start_real_time);
      fprintf(stderr, " Encoding time: %.3lf s.\n", encoding_time);
      fprintf(stderr, " Encoding wall time: %.3lf s.\n", wall_time);
      fprintf(stderr, " Encoding CPU usage: %.2lf%%\n", encoding_time/wall_time*100.f);
      fprintf(stderr, " FPS: %.2lf\n", ((double)stat_frames)/wall_time);
    }

    fclose(input);
    fclose(output);
    if(recout != NULL) fclose(recout);
    
    for (i = 0; i <= encoder.owf; ++i) {
      encoder_state_finalize(&encoder_states[i]);
    }

    free(encoder_states);
  }

  // Deallocating
  config_destroy(cfg);
  encoder_control_finalize(&encoder);

  free_exp_golomb();
  
  strategyselector_free();
  
  CHECKPOINTS_FINALIZE();

  return EXIT_SUCCESS;

exit_failure:
  if (cfg) config_destroy(cfg);
  if (input) fclose(input);
  if (output) fclose(output);
  if (recout) fclose(recout);
  strategyselector_free();
  CHECKPOINTS_FINALIZE();
  return EXIT_FAILURE;
}