コード例 #1
0
void vp8_arch_x86_decode_init(VP8D_COMP *pbi)
{
    int flags = x86_simd_caps();

    /* Note:
     *
     * This platform can be built without runtime CPU detection as well. If
     * you modify any of the function mappings present in this file, be sure
     * to also update them in static mapings (<arch>/filename_<arch>.h)
     */
#if CONFIG_RUNTIME_CPU_DETECT
    /* Override default functions with fastest ones for this CPU. */
#if HAVE_MMX
    if (flags & HAS_MMX)
    {
        pbi->dequant.block               = vp8_dequantize_b_mmx;
        pbi->dequant.idct_add            = vp8_dequant_idct_add_mmx;
        pbi->dequant.dc_idct_add         = vp8_dequant_dc_idct_add_mmx;
        pbi->dequant.dc_idct_add_y_block = vp8_dequant_dc_idct_add_y_block_mmx;
        pbi->dequant.idct_add_y_block    = vp8_dequant_idct_add_y_block_mmx;
        pbi->dequant.idct_add_uv_block   = vp8_dequant_idct_add_uv_block_mmx;
    }
#endif
#if HAVE_SSE2
    if (flags & HAS_SSE2)
    {
        pbi->dequant.dc_idct_add_y_block = vp8_dequant_dc_idct_add_y_block_sse2;
        pbi->dequant.idct_add_y_block    = vp8_dequant_idct_add_y_block_sse2;
        pbi->dequant.idct_add_uv_block   = vp8_dequant_idct_add_uv_block_sse2;
    }
#endif

#endif
}
コード例 #2
0
void vp8_machine_specific_config(VP8_COMMON *ctx)
{
#if CONFIG_MULTITHREAD
    ctx->processor_core_count = get_cpu_count();
#endif /* CONFIG_MULTITHREAD */

#if ARCH_ARM
    ctx->cpu_caps = arm_cpu_caps();
#elif ARCH_X86 || ARCH_X86_64
    ctx->cpu_caps = x86_simd_caps();
#endif
}
コード例 #3
0
void vp8_arch_x86_encoder_init(VP8_COMP *cpi)
{
#if CONFIG_RUNTIME_CPU_DETECT
    int flags = x86_simd_caps();

    /* Note:
     *
     * This platform can be built without runtime CPU detection as well. If
     * you modify any of the function mappings present in this file, be sure
     * to also update them in static mapings (<arch>/filename_<arch>.h)
     */

    /* Override default functions with fastest ones for this CPU. */
#if HAVE_MMX
    if (flags & HAS_MMX)
    {
        cpi->rtcd.variance.sad16x16              = vp8_sad16x16_mmx;
        cpi->rtcd.variance.sad16x8               = vp8_sad16x8_mmx;
        cpi->rtcd.variance.sad8x16               = vp8_sad8x16_mmx;
        cpi->rtcd.variance.sad8x8                = vp8_sad8x8_mmx;
        cpi->rtcd.variance.sad4x4                = vp8_sad4x4_mmx;

        cpi->rtcd.variance.var4x4                = vp8_variance4x4_mmx;
        cpi->rtcd.variance.var8x8                = vp8_variance8x8_mmx;
        cpi->rtcd.variance.var8x16               = vp8_variance8x16_mmx;
        cpi->rtcd.variance.var16x8               = vp8_variance16x8_mmx;
        cpi->rtcd.variance.var16x16              = vp8_variance16x16_mmx;

        cpi->rtcd.variance.subpixvar4x4          = vp8_sub_pixel_variance4x4_mmx;
        cpi->rtcd.variance.subpixvar8x8          = vp8_sub_pixel_variance8x8_mmx;
        cpi->rtcd.variance.subpixvar8x16         = vp8_sub_pixel_variance8x16_mmx;
        cpi->rtcd.variance.subpixvar16x8         = vp8_sub_pixel_variance16x8_mmx;
        cpi->rtcd.variance.subpixvar16x16        = vp8_sub_pixel_variance16x16_mmx;
        cpi->rtcd.variance.halfpixvar16x16_h     = vp8_variance_halfpixvar16x16_h_mmx;
        cpi->rtcd.variance.halfpixvar16x16_v     = vp8_variance_halfpixvar16x16_v_mmx;
        cpi->rtcd.variance.halfpixvar16x16_hv    = vp8_variance_halfpixvar16x16_hv_mmx;
        cpi->rtcd.variance.subpixmse16x16        = vp8_sub_pixel_mse16x16_mmx;

        cpi->rtcd.variance.mse16x16              = vp8_mse16x16_mmx;
        cpi->rtcd.variance.getmbss               = vp8_get_mb_ss_mmx;

        cpi->rtcd.variance.get4x4sse_cs          = vp8_get4x4sse_cs_mmx;

        cpi->rtcd.fdct.short4x4                  = vp8_short_fdct4x4_mmx;
        cpi->rtcd.fdct.short8x4                  = vp8_short_fdct8x4_mmx;
        cpi->rtcd.fdct.fast4x4                   = vp8_short_fdct4x4_mmx;
        cpi->rtcd.fdct.fast8x4                   = vp8_short_fdct8x4_mmx;

        cpi->rtcd.fdct.walsh_short4x4            = vp8_short_walsh4x4_c;

        cpi->rtcd.encodemb.berr                  = vp8_block_error_mmx;
        cpi->rtcd.encodemb.mberr                 = vp8_mbblock_error_mmx;
        cpi->rtcd.encodemb.mbuverr               = vp8_mbuverror_mmx;
        cpi->rtcd.encodemb.subb                  = vp8_subtract_b_mmx;
        cpi->rtcd.encodemb.submby                = vp8_subtract_mby_mmx;
        cpi->rtcd.encodemb.submbuv               = vp8_subtract_mbuv_mmx;

        /*cpi->rtcd.quantize.fastquantb            = vp8_fast_quantize_b_mmx;*/
    }
#endif

#if HAVE_SSE2
    if (flags & HAS_SSE2)
    {
        cpi->rtcd.variance.sad16x16              = vp8_sad16x16_wmt;
        cpi->rtcd.variance.sad16x8               = vp8_sad16x8_wmt;
        cpi->rtcd.variance.sad8x16               = vp8_sad8x16_wmt;
        cpi->rtcd.variance.sad8x8                = vp8_sad8x8_wmt;
        cpi->rtcd.variance.sad4x4                = vp8_sad4x4_wmt;
        cpi->rtcd.variance.copy32xn              = vp8_copy32xn_sse2;

        cpi->rtcd.variance.var4x4                = vp8_variance4x4_wmt;
        cpi->rtcd.variance.var8x8                = vp8_variance8x8_wmt;
        cpi->rtcd.variance.var8x16               = vp8_variance8x16_wmt;
        cpi->rtcd.variance.var16x8               = vp8_variance16x8_wmt;
        cpi->rtcd.variance.var16x16              = vp8_variance16x16_wmt;

        cpi->rtcd.variance.subpixvar4x4          = vp8_sub_pixel_variance4x4_wmt;
        cpi->rtcd.variance.subpixvar8x8          = vp8_sub_pixel_variance8x8_wmt;
        cpi->rtcd.variance.subpixvar8x16         = vp8_sub_pixel_variance8x16_wmt;
        cpi->rtcd.variance.subpixvar16x8         = vp8_sub_pixel_variance16x8_wmt;
        cpi->rtcd.variance.subpixvar16x16        = vp8_sub_pixel_variance16x16_wmt;
        cpi->rtcd.variance.halfpixvar16x16_h     = vp8_variance_halfpixvar16x16_h_wmt;
        cpi->rtcd.variance.halfpixvar16x16_v     = vp8_variance_halfpixvar16x16_v_wmt;
        cpi->rtcd.variance.halfpixvar16x16_hv    = vp8_variance_halfpixvar16x16_hv_wmt;
        cpi->rtcd.variance.subpixmse16x16        = vp8_sub_pixel_mse16x16_wmt;

        cpi->rtcd.variance.mse16x16              = vp8_mse16x16_wmt;
        cpi->rtcd.variance.getmbss               = vp8_get_mb_ss_sse2;

        /* cpi->rtcd.variance.get4x4sse_cs  not implemented for wmt */;

        cpi->rtcd.fdct.short4x4                  = vp8_short_fdct4x4_sse2;
        cpi->rtcd.fdct.short8x4                  = vp8_short_fdct8x4_sse2;
        cpi->rtcd.fdct.fast4x4                   = vp8_short_fdct4x4_sse2;
        cpi->rtcd.fdct.fast8x4                   = vp8_short_fdct8x4_sse2;

        cpi->rtcd.fdct.walsh_short4x4            = vp8_short_walsh4x4_sse2 ;

        cpi->rtcd.encodemb.berr                  = vp8_block_error_xmm;
        cpi->rtcd.encodemb.mberr                 = vp8_mbblock_error_xmm;
        cpi->rtcd.encodemb.mbuverr               = vp8_mbuverror_xmm;
        cpi->rtcd.encodemb.subb                  = vp8_subtract_b_sse2;
        cpi->rtcd.encodemb.submby                = vp8_subtract_mby_sse2;
        cpi->rtcd.encodemb.submbuv               = vp8_subtract_mbuv_sse2;

        cpi->rtcd.quantize.quantb                = vp8_regular_quantize_b_sse2;
        cpi->rtcd.quantize.fastquantb            = vp8_fast_quantize_b_sse2;

#if !(CONFIG_REALTIME_ONLY)
        cpi->rtcd.temporal.apply                 = vp8_temporal_filter_apply_sse2;
#endif
    }
#endif

#if HAVE_SSE3
    if (flags & HAS_SSE3)
    {
        cpi->rtcd.variance.sad16x16              = vp8_sad16x16_sse3;
        cpi->rtcd.variance.sad16x16x3            = vp8_sad16x16x3_sse3;
        cpi->rtcd.variance.sad16x8x3             = vp8_sad16x8x3_sse3;
        cpi->rtcd.variance.sad8x16x3             = vp8_sad8x16x3_sse3;
        cpi->rtcd.variance.sad8x8x3              = vp8_sad8x8x3_sse3;
        cpi->rtcd.variance.sad4x4x3              = vp8_sad4x4x3_sse3;
        cpi->rtcd.search.full_search             = vp8_full_search_sadx3;
        cpi->rtcd.variance.sad16x16x4d           = vp8_sad16x16x4d_sse3;
        cpi->rtcd.variance.sad16x8x4d            = vp8_sad16x8x4d_sse3;
        cpi->rtcd.variance.sad8x16x4d            = vp8_sad8x16x4d_sse3;
        cpi->rtcd.variance.sad8x8x4d             = vp8_sad8x8x4d_sse3;
        cpi->rtcd.variance.sad4x4x4d             = vp8_sad4x4x4d_sse3;
        cpi->rtcd.variance.copy32xn              = vp8_copy32xn_sse3;
        cpi->rtcd.search.diamond_search          = vp8_diamond_search_sadx4;
        cpi->rtcd.search.refining_search         = vp8_refining_search_sadx4;
    }
#endif

#if HAVE_SSSE3
    if (flags & HAS_SSSE3)
    {
        cpi->rtcd.variance.sad16x16x3            = vp8_sad16x16x3_ssse3;
        cpi->rtcd.variance.sad16x8x3             = vp8_sad16x8x3_ssse3;

        cpi->rtcd.variance.subpixvar16x8         = vp8_sub_pixel_variance16x8_ssse3;
        cpi->rtcd.variance.subpixvar16x16        = vp8_sub_pixel_variance16x16_ssse3;

        cpi->rtcd.quantize.fastquantb            = vp8_fast_quantize_b_ssse3;

#if CONFIG_INTERNAL_STATS
#if ARCH_X86_64
        cpi->rtcd.variance.ssimpf_8x8            = vp8_ssim_parms_8x8_sse3;
        cpi->rtcd.variance.ssimpf                = vp8_ssim_parms_16x16_sse3;
#endif
#endif

    }
#endif



#if HAVE_SSE4_1
    if (flags & HAS_SSE4_1)
    {
        cpi->rtcd.variance.sad16x16x8            = vp8_sad16x16x8_sse4;
        cpi->rtcd.variance.sad16x8x8             = vp8_sad16x8x8_sse4;
        cpi->rtcd.variance.sad8x16x8             = vp8_sad8x16x8_sse4;
        cpi->rtcd.variance.sad8x8x8              = vp8_sad8x8x8_sse4;
        cpi->rtcd.variance.sad4x4x8              = vp8_sad4x4x8_sse4;
        cpi->rtcd.search.full_search             = vp8_full_search_sadx8;

        cpi->rtcd.quantize.quantb                = vp8_regular_quantize_b_sse4;
    }
#endif

#endif
}
コード例 #4
0
int test_change_cpu_dec(int argc,
                        const char** argv,
                        const std::string &working_dir,
                        const std::string sub_folder_str,
                        int test_type,
                        int delete_ivf,
                        int artifact_detection)
{
#if defined(ARM)
    printf("\nTEST NOT SUPPORTED FOR ARM.\n");
    return kTestFailed;
#endif
#if defined(_PPC)
    printf("\nTEST NOT SUPPORTED FOR PPC.\n");
    return kTestFailed;
#else
    char *comp_out_str = "Version";
    char *test_dir = "test_change_cpu_dec";
    int input_ver = vpxt_check_arg_input(argv[1], argc);

    if (input_ver < 0)
        return vpxt_test_help(argv[1], 0);

    std::string input = argv[2];
    int mode = atoi(argv[3]);
    int bitrate = atoi(argv[4]);
    int version_num = atoi(argv[5]);
    std::string enc_format = argv[6];
    std::string dec_format = argv[7];

    unsigned int total_ms = 0;
    unsigned int total_ms_2 = 0;

    int speed = 0;
    int fail = 0;
    int modes_run = 0;

    int simd_caps = x86_simd_caps();
    char simd_caps_orig_char[10];
    vpxt_itoa_custom(simd_caps, simd_caps_orig_char, 10);

    //////////// Formatting Test Specific directory ////////////
    std::string cur_test_dir_str;
    std::string file_index_str;
    char main_test_dir_char[255] = "";
    char file_index_output_char[255] = "";

    if (initialize_test_directory(argc, argv, test_type, working_dir, test_dir,
        cur_test_dir_str, file_index_str, main_test_dir_char,
        file_index_output_char, sub_folder_str) == 11)
        return kTestErrFileMismatch;

    std::string cpu_dec_only_enc = cur_test_dir_str + slashCharStr() + test_dir
        + "_compression";
    vpxt_enc_format_append(cpu_dec_only_enc, enc_format);

    std::string cpu_dec_only_dec = cur_test_dir_str + slashCharStr() + test_dir
        + "_decompression";

    std::string cpu_dec_only_dec_none = cpu_dec_only_dec + "_none";
    vpxt_dec_format_append(cpu_dec_only_dec_none, dec_format);
    std::string cpu_dec_only_dec_mmx = cpu_dec_only_dec + "_mmx";
    vpxt_dec_format_append(cpu_dec_only_dec_mmx, dec_format);
    std::string cpu_dec_only_dec_sse = cpu_dec_only_dec + "_sse";
    vpxt_dec_format_append(cpu_dec_only_dec_sse, dec_format);
    std::string cpu_dec_only_dec_sse2 = cpu_dec_only_dec + "_sse2";
    vpxt_dec_format_append(cpu_dec_only_dec_sse2, dec_format);
    std::string cpu_dec_only_dec_sse3 = cpu_dec_only_dec + "_sse3";
    vpxt_dec_format_append(cpu_dec_only_dec_sse3, dec_format);
    std::string cpu_dec_only_dec_ssse3 = cpu_dec_only_dec + "_ssse3";
    vpxt_dec_format_append(cpu_dec_only_dec_ssse3, dec_format);
    std::string cpu_dec_only_dec_sse4_1 = cpu_dec_only_dec + "_sse4_1";
    vpxt_dec_format_append(cpu_dec_only_dec_sse4_1, dec_format);

    ///////////// Open Output File and Print Header ////////////
    std::string text_file_str = cur_test_dir_str + slashCharStr() + test_dir;
    FILE *fp;

    vpxt_open_output_file(test_type, text_file_str, fp);
    vpxt_print_header(argc, argv, main_test_dir_char, cur_test_dir_str,
        test_dir, test_type);

    VP8_CONFIG opt;
    vpxt_default_parameters(opt);

    /////////////////// Use Custom Settings ///////////////////
    if(vpxt_use_custom_settings(argv, argc, input_ver, fp, file_index_str,
        file_index_output_char, test_type, opt, bitrate)
        == kTestIndeterminate)
        return kTestIndeterminate;

    opt.target_bandwidth = bitrate;
    opt.Mode = MODE_GOODQUALITY;
    opt.Version = version_num;
    int compress_int = opt.Version;
    vpxt_determinate_parameters(opt);

    int counter = 0;
    int mode_2 = 0;

    // Run Test only (Runs Test, Sets up test to be run, or skips compresion of
    // files)
    if (test_type == kTestOnly)
    {
        std::vector<std::string> decompression_vector;

        if (vpxt_file_exists_check(cpu_dec_only_dec_none))
            decompression_vector.push_back(cpu_dec_only_dec_none);

        if (vpxt_file_exists_check(cpu_dec_only_dec_mmx))
            decompression_vector.push_back(cpu_dec_only_dec_mmx);

        if (vpxt_file_exists_check(cpu_dec_only_dec_sse))
            decompression_vector.push_back(cpu_dec_only_dec_sse);

        if (vpxt_file_exists_check(cpu_dec_only_dec_sse2))
            decompression_vector.push_back(cpu_dec_only_dec_sse2);

        if (vpxt_file_exists_check(cpu_dec_only_dec_sse3))
            decompression_vector.push_back(cpu_dec_only_dec_sse3);

        if (vpxt_file_exists_check(cpu_dec_only_dec_ssse3))
            decompression_vector.push_back(cpu_dec_only_dec_ssse3);

        if (vpxt_file_exists_check(cpu_dec_only_dec_sse4_1))
            decompression_vector.push_back(cpu_dec_only_dec_sse4_1);

        modes_run = decompression_vector.size();

        total_ms = vpxt_time_return(decompression_vector[0].c_str(), 1);

        unsigned int current_dec_file = 0;

        while (current_dec_file < decompression_vector.size())
        {

            total_ms_2 =
                vpxt_time_return(decompression_vector[current_dec_file].c_str(), 1);

            if (current_dec_file >= 1)
            {
                tprintf(PRINT_BTH, "\n");

                char comp_file_index_output_char[255];
                char comp_file_2[255];
                vpxt_file_name(decompression_vector[current_dec_file-1].c_str(),
                    comp_file_index_output_char, 0);
                vpxt_file_name(decompression_vector[current_dec_file].c_str(),
                    comp_file_2, 0);

                tprintf(PRINT_BTH, "\nComparing %s to %s\n",
                    comp_file_index_output_char, comp_file_2);

                int lng_rc =
                  vpxt_compare_enc(decompression_vector[current_dec_file-1].c_str(),
                  decompression_vector[current_dec_file].c_str(), 0);

                if (lng_rc >= 0)
                {
                    tprintf(PRINT_BTH, "\n * Fail: Files differ at frame: %i",
                        lng_rc);
                    fail = 1;
                }

                if (lng_rc == -1)
                    tprintf(PRINT_BTH, " * Files are identical");

                if (lng_rc == -2)
                {
                    tprintf(PRINT_BTH, "\n * Fail: File 2 ends before File 1."
                        "\n");
                    fail = 1;
                }

                if (lng_rc == -3)
                {
                    tprintf(PRINT_BTH, "\n * Fail: File 1 ends before File 2."
                        "\n");
                    fail = 1;
                }
            }

            current_dec_file++;
        }

        tprintf(PRINT_BTH, "\n");
    }
    else
    {
        std::vector<std::string> decompression_vector;
        opt.Mode = mode;

        if (vpxt_compress(input.c_str(), cpu_dec_only_enc.c_str(), speed,
            bitrate, opt, comp_out_str, compress_int, 0, enc_format,
            kSetConfigOff) == -1)
        {
            fclose(fp);
            record_test_complete(file_index_str, file_index_output_char, test_type);
            return kTestIndeterminate;
        }

        putenv("VPX_SIMD_CAPS=0");

        std::string output_2_str = cpu_dec_only_dec + "_none";
        vpxt_dec_format_append(output_2_str, dec_format);

        tprintf(PRINT_BTH, "\n\nDetected CPU capability: none");
        unsigned int cpu_tick_1 = 0;
        total_ms = vpxt_decompress_time_and_output(cpu_dec_only_enc.c_str()
            , output_2_str.c_str(), cpu_tick_1, dec_format, 1);
        decompression_vector.push_back(output_2_str);

        if (total_ms == -1)
        {
            fclose(fp);
            record_test_complete(file_index_str, file_index_output_char, test_type);
            std::string simd_caps_str = "VPX_SIMD_CAPS=";
            simd_caps_str += simd_caps_orig_char;
            putenv((char*)simd_caps_str.c_str());
            return kTestIndeterminate;
        }

        tprintf(PRINT_BTH, "\n");

        int counter_max = 64;
        counter++;
        int i = 1;

        while (counter < counter_max)
        {
            int cpu_found = 0;
            int has_check = (counter + 1) / 2;

            if ((simd_caps & HAS_MMX)    == has_check)
                cpu_found = 1;

            if ((simd_caps & HAS_SSE)    == has_check)
                cpu_found = 1;

            if ((simd_caps & HAS_SSE2)   == has_check)
                cpu_found = 1;

            if ((simd_caps & HAS_SSE3)   == has_check)
                cpu_found = 1;

            if ((simd_caps & HAS_SSSE3)  == has_check)
                cpu_found = 1;

            if ((simd_caps & HAS_SSE4_1) == has_check)
                cpu_found = 1;

            if (cpu_found == 1)
            {
                std::string cpu_str;
                tprintf(PRINT_BTH, "\nDetected CPU capability: ");

                if ((simd_caps & HAS_MMX)    == has_check)
                    cpu_str = "_mmx";

                if ((simd_caps & HAS_SSE)    == has_check)
                    cpu_str = "_sse";

                if ((simd_caps & HAS_SSE2)   == has_check)
                    cpu_str = "_sse2";

                if ((simd_caps & HAS_SSE3)   == has_check)
                    cpu_str = "_sse3";

                if ((simd_caps & HAS_SSSE3)  == has_check)
                    cpu_str = "_ssse3";

                if ((simd_caps & HAS_SSE4_1) == has_check)
                    cpu_str = "_sse4_1";

                tprintf(PRINT_BTH, "%s", cpu_str.c_str());

                std::string cpu_id_str = "VPX_SIMD_CAPS=";
                char counter_char[10];
                vpxt_itoa_custom(counter, counter_char, 10);
                cpu_id_str += counter_char;

                char cpu_char[255];
                snprintf(cpu_char, 255, cpu_id_str.c_str());
                putenv(cpu_char);

                //////////////////////////////////
                /////// Compresion and time ///////

                std::string change_cpu_dec_out_file_1 = cpu_dec_only_dec;
                std::string change_cpu_dec_out_file_2 = cpu_dec_only_dec;

                char count[20];
                vpxt_itoa_custom(counter, count, 10);
                change_cpu_dec_out_file_1 += cpu_str.c_str();
                vpxt_dec_format_append(change_cpu_dec_out_file_1, dec_format);

                unsigned int cpu_tick_2 = 0;
                total_ms_2 =
                 vpxt_decompress_time_and_output(cpu_dec_only_enc.c_str(),
                 change_cpu_dec_out_file_1.c_str(), cpu_tick_2, dec_format, 1);
                decompression_vector.push_back(change_cpu_dec_out_file_1);

                if (total_ms_2 == -1)
                {
                    fclose(fp);
                    record_test_complete(file_index_str, file_index_output_char,
                        test_type);
                    std::string simd_caps_str = "VPX_SIMD_CAPS=" +
                        *simd_caps_orig_char;
                    putenv((char*)simd_caps_str.c_str());
                    return kTestIndeterminate;
                }

                int count_old = (counter - 1);
                vpxt_itoa_custom(count_old, count, 10);
                change_cpu_dec_out_file_2 += cpu_str.c_str();
                vpxt_dec_format_append(change_cpu_dec_out_file_2, dec_format);

                if (test_type != 2)
                {
                    char comp_file_index_output_char[255];
                    char comp_file_2[255];
                    vpxt_file_name(
                        decompression_vector[decompression_vector.size()-1].c_str(),
                        comp_file_index_output_char, 0);
                    vpxt_file_name(
                        decompression_vector[decompression_vector.size()-2].c_str(),
                        comp_file_2, 0);

                    tprintf(PRINT_BTH, "\nComparing %s to %s\n",
                        comp_file_index_output_char, comp_file_2);

                    int lng_rc =
                        vpxt_compare_dec(
                        decompression_vector[decompression_vector.size()-1].c_str(),
                        decompression_vector[decompression_vector.size()-2].c_str());

                    if (lng_rc >= 0)
                    {
                        tprintf(PRINT_BTH, "\n * Fail: Files differ at frame: "
                            "%i on file number %i", lng_rc, i);
                        fail = 1;
                    }

                    if (lng_rc == -1)
                        tprintf(PRINT_BTH, " * Files are identical");

                    if (lng_rc == -2)
                    {
                        tprintf(PRINT_BTH, "\n * Fail: File 2 ends before File "
                            "1.\n");
                        fail = 1;
                    }

                    if (lng_rc == -3)
                    {
                        tprintf(PRINT_BTH, "\n * Fail: File 1 ends before File "
                            "2.\n");
                        fail = 1;
                    }
                }
            }

            counter = ((counter + 1) * 2) - 1;
            tprintf(PRINT_BTH, "\n\n");
            i++;
        }

        modes_run = decompression_vector.size();
    }

    // Create Compression only stop test short.
    if (test_type == kCompOnly)
    {
        // Compression only run
        fclose(fp);
        record_test_complete(file_index_str, file_index_output_char, test_type);
        std::string simd_caps_str = "VPX_SIMD_CAPS=";
        simd_caps_str += simd_caps_orig_char;
        putenv((char*)simd_caps_str.c_str());
        return kTestEncCreated;
    }

    int test_state = kTestPassed;
    tprintf(PRINT_BTH, "\nResults:\n\n");

    if (fail == 0)
    {
        vpxt_formated_print(RESPRT, "All Files Identical - Passed");
        tprintf(PRINT_BTH, "\n");
    }

    if (fail == 1)
    {
        vpxt_formated_print(RESPRT, "All Files not Identical - Failed");
        tprintf(PRINT_BTH, "\n");
        test_state = kTestFailed;
    }

    if (modes_run == 7)
    {
        vpxt_formated_print(RESPRT, "All instruction sets run - Passed");
        tprintf(PRINT_BTH, "\n");
    }

    if (modes_run != 7)
    {
        vpxt_formated_print(RESPRT, "Not all instruction sets run - MinPassed");
        tprintf(PRINT_BTH, "\n");

        if (test_state != kTestFailed)
            test_state = kTestMinPassed;
    }

    if (total_ms != total_ms_2)
    {
        vpxt_formated_print(RESPRT, "Decompress times are not equal - Passed");
        tprintf(PRINT_BTH, "\n");
    }

    if (total_ms == total_ms_2)
    {
        vpxt_formated_print(RESPRT, "CPU changes are not effecting the runtime "
            "- MinPassed");
        tprintf(PRINT_BTH, "\n");
        test_state = kTestMinPassed;
    }

    if (test_state == kTestMinPassed)
        tprintf(PRINT_BTH, "\nMinPass\n");
    if (test_state == kTestPassed)
        tprintf(PRINT_BTH, "\nPassed\n");
    if (test_state == kTestFailed)
        tprintf(PRINT_BTH, "\nFailed\n");

    if (delete_ivf)
        vpxt_delete_files(8, cpu_dec_only_enc.c_str(),
        cpu_dec_only_dec_none.c_str(), cpu_dec_only_dec_mmx.c_str(),
        cpu_dec_only_dec_sse.c_str(), cpu_dec_only_dec_sse2.c_str(),
        cpu_dec_only_dec_sse3.c_str(), cpu_dec_only_dec_ssse3.c_str(),
        cpu_dec_only_dec_sse4_1.c_str());

    fclose(fp);
    record_test_complete(file_index_str, file_index_output_char, test_type);
    std::string simd_caps_str = "VPX_SIMD_CAPS=";
    simd_caps_str += simd_caps_orig_char;
    putenv((char*)simd_caps_str.c_str());
    return test_state;
#endif
}
コード例 #5
0
void vp8_arch_x86_common_init(VP8_COMMON *ctx)
{
#if CONFIG_RUNTIME_CPU_DETECT
    VP8_COMMON_RTCD *rtcd = &ctx->rtcd;
    int flags = x86_simd_caps();

    /* Note:
     *
     * This platform can be built without runtime CPU detection as well. If
     * you modify any of the function mappings present in this file, be sure
     * to also update them in static mapings (<arch>/filename_<arch>.h)
     */

    /* Override default functions with fastest ones for this CPU. */
#if HAVE_MMX

    if (flags & HAS_MMX)
    {
        rtcd->idct.idct1        = vp8_short_idct4x4llm_1_mmx;
        rtcd->idct.idct16       = vp8_short_idct4x4llm_mmx;
        rtcd->idct.idct1_scalar_add = vp8_dc_only_idct_add_mmx;
        rtcd->idct.iwalsh16     = vp8_short_inv_walsh4x4_mmx;
        rtcd->idct.iwalsh1     = vp8_short_inv_walsh4x4_1_mmx;



        rtcd->recon.recon       = vp8_recon_b_mmx;
        rtcd->recon.copy8x8     = vp8_copy_mem8x8_mmx;
        rtcd->recon.copy8x4     = vp8_copy_mem8x4_mmx;
        rtcd->recon.copy16x16   = vp8_copy_mem16x16_mmx;

        rtcd->subpix.sixtap16x16   = vp8_sixtap_predict16x16_mmx;
        rtcd->subpix.sixtap8x8     = vp8_sixtap_predict8x8_mmx;
        rtcd->subpix.sixtap8x4     = vp8_sixtap_predict8x4_mmx;
        rtcd->subpix.sixtap4x4     = vp8_sixtap_predict4x4_mmx;
        rtcd->subpix.bilinear16x16 = vp8_bilinear_predict16x16_mmx;
        rtcd->subpix.bilinear8x8   = vp8_bilinear_predict8x8_mmx;
        rtcd->subpix.bilinear8x4   = vp8_bilinear_predict8x4_mmx;
        rtcd->subpix.bilinear4x4   = vp8_bilinear_predict4x4_mmx;

        rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_mmx;
        rtcd->loopfilter.normal_b_v  = vp8_loop_filter_bv_mmx;
        rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_mmx;
        rtcd->loopfilter.normal_b_h  = vp8_loop_filter_bh_mmx;
        rtcd->loopfilter.simple_mb_v = vp8_loop_filter_simple_vertical_edge_mmx;
        rtcd->loopfilter.simple_b_v  = vp8_loop_filter_bvs_mmx;
        rtcd->loopfilter.simple_mb_h = vp8_loop_filter_simple_horizontal_edge_mmx;
        rtcd->loopfilter.simple_b_h  = vp8_loop_filter_bhs_mmx;

#if CONFIG_POSTPROC
        rtcd->postproc.down        = vp8_mbpost_proc_down_mmx;
        /*rtcd->postproc.across      = vp8_mbpost_proc_across_ip_c;*/
        rtcd->postproc.downacross  = vp8_post_proc_down_and_across_mmx;
        rtcd->postproc.addnoise    = vp8_plane_add_noise_mmx;
#endif
    }

#endif
#if HAVE_SSE2

    if (flags & HAS_SSE2)
    {
        rtcd->recon.recon2      = vp8_recon2b_sse2;
        rtcd->recon.recon4      = vp8_recon4b_sse2;
        rtcd->recon.copy16x16   = vp8_copy_mem16x16_sse2;
        rtcd->recon.build_intra_predictors_mbuv =
            vp8_build_intra_predictors_mbuv_sse2;
        rtcd->recon.build_intra_predictors_mbuv_s =
            vp8_build_intra_predictors_mbuv_s_sse2;

        rtcd->idct.iwalsh16     = vp8_short_inv_walsh4x4_sse2;

        rtcd->subpix.sixtap16x16   = vp8_sixtap_predict16x16_sse2;
        rtcd->subpix.sixtap8x8     = vp8_sixtap_predict8x8_sse2;
        rtcd->subpix.sixtap8x4     = vp8_sixtap_predict8x4_sse2;
        rtcd->subpix.bilinear16x16 = vp8_bilinear_predict16x16_sse2;
        rtcd->subpix.bilinear8x8   = vp8_bilinear_predict8x8_sse2;

        rtcd->loopfilter.normal_mb_v = vp8_loop_filter_mbv_sse2;
        rtcd->loopfilter.normal_b_v  = vp8_loop_filter_bv_sse2;
        rtcd->loopfilter.normal_mb_h = vp8_loop_filter_mbh_sse2;
        rtcd->loopfilter.normal_b_h  = vp8_loop_filter_bh_sse2;
        rtcd->loopfilter.simple_mb_v = vp8_loop_filter_simple_vertical_edge_sse2;
        rtcd->loopfilter.simple_b_v  = vp8_loop_filter_bvs_sse2;
        rtcd->loopfilter.simple_mb_h = vp8_loop_filter_simple_horizontal_edge_sse2;
        rtcd->loopfilter.simple_b_h  = vp8_loop_filter_bhs_sse2;

#if CONFIG_POSTPROC
        rtcd->postproc.down        = vp8_mbpost_proc_down_xmm;
        rtcd->postproc.across      = vp8_mbpost_proc_across_ip_xmm;
        rtcd->postproc.downacross  = vp8_post_proc_down_and_across_xmm;
        rtcd->postproc.addnoise    = vp8_plane_add_noise_wmt;
#endif
    }

#endif

#if HAVE_SSSE3

    if (flags & HAS_SSSE3)
    {
        rtcd->subpix.sixtap16x16   = vp8_sixtap_predict16x16_ssse3;
        rtcd->subpix.sixtap8x8     = vp8_sixtap_predict8x8_ssse3;
        rtcd->subpix.sixtap8x4     = vp8_sixtap_predict8x4_ssse3;
        rtcd->subpix.sixtap4x4     = vp8_sixtap_predict4x4_ssse3;
        rtcd->subpix.bilinear16x16 = vp8_bilinear_predict16x16_ssse3;
        rtcd->subpix.bilinear8x8   = vp8_bilinear_predict8x8_ssse3;

        rtcd->recon.build_intra_predictors_mbuv =
            vp8_build_intra_predictors_mbuv_ssse3;
        rtcd->recon.build_intra_predictors_mbuv_s =
            vp8_build_intra_predictors_mbuv_s_ssse3;
    }
#endif

#endif
}