lzop2_multi.c

Go to the documentation of this file.

/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
                      #2023 X March 21 19:50 PM Brasília Time
 
*                                                                             *
*                   Licensa de Copia (C) <2024>  <Aurora Boreal>              *
*                                                                             *
*     Este  programa  e software livre: voce pode redistribuir isto e/ou      *
*     modificar  isto sobre os termos do  GNU Licensa Geral Pública como     25
*     publicado  pela Fundacao  de Software  Livre, tanto a versão 3  da      *
*     Licensa, ou (dependendo da sua opcao) qualquer versao posterior.        *
*                                                                             *
*     Este  programa e distribuido na  esperanca que isto vai  ser util,      *
*     mas SEM  QUALQUER GARANTIA; sem  ate mesmo a implicada garantia de      *
*     COMERCIALIZAcaO ou CABIMENTO PARA UM FIM PARTICULAR.  Veja a            *
*     Licensa Geral Publica para mais detalhes.                               *
*                                                                             *
*     Você deve ter recebido uma  cópia da LICENSA GERAL PUBLICA e a GNU      *
*     Licensa Publica Menor junto com este programa                           *
*     Se não, veja <http://www.gnu.org/licenses/>.                            *
*                                                                             *
*     Suporte: sourceforge.net github.com                                   *
*                                                                             *
* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * *
 
*       Pereira: arsoftware25@gmail.com ricardo@arsoftware.net.br             *
*           xcx: arsoftware10@gmail.com   charli@arsoftware.net.br            *
         Yasmin:                          yasmin@arsoftware.net.br            *
                                              pereira1001@users.sourceforge.net
                                                                             */
 
                                                                            
static uint64_t bytes_in_each_slice_z[129];
static uint64_t offset_of_each_slice_z[129];
 
extern int *cores_used_z_14;
 
#include "lzop2_thread.c"
 
int __valquiriacall compress2_uncompress_k_real_mt_z_14(char *input_z, char *output_z)
{
    //enum error_modes_J juliete_result = ERROR_AMANDA_NO_ERROR__;
    my_thread_struct_z *ptr_my_struct_z;
    FILE *dest_z;
    FILE *input_file;
    FILE *temp_z = NULL;
    int ret_z;
    int ret2_z;
    int retvalue_z = 0;
    int n_threads_copy;
    int n_thread_counter;
    int ret_arp;
    int thread_counter = 0;
    int i_z;
    int64_t remaining_z;
    char signature_z[5] = "AR__";
    static char buffer[CHUNK];
    ar_data ar = {0};
 
    thread_return_value_z_14 = 0; //initial thread error value
 
    //n_threads_copy = n_threads_z_14;
 
    n_thread_counter = 0;
 
    //primeiro precisa detectar quantos threads foram usados no arquivo compactado
 
    if (true)
    {
 
        input_file = _wfopen(utf8_2_wide_dl(input_z), L"rb");
 
    }
 
    if (NULL == input_file)
    {
        return 1; //Cannot open input file
    }
 
    signature_z[3] = '_' - 11; // new lzop2 multi-thread and single-thread signature
 
    while (1)
    {
 
        memset(&ar, 0, sizeof(ar));
        ret_arp = fread(&ar, 1, sizeof(ar), input_file);
 
        if (0 == ret_arp)
        {
            goto saida_z;
        }
 
        if (ret_arp != sizeof(ar))
        {
            retvalue_z = 5;
            goto saida_z;
        }
 
        if (0 != memcmp(ar.string, signature_z, 4))
        {
            retvalue_z = 7;
            goto saida_z;
        }
 
        ret_arp = fread(&remaining_z, 1, sizeof(remaining_z), input_file);
 
        if (sizeof(remaining_z) != ret_arp)
        {
            retvalue_z = 5;
            goto saida_z;
        }
        bytes_in_each_slice_z[thread_counter] = remaining_z;
        offset_of_each_slice_z[thread_counter] = _ftelli64(input_file);
 
        _fseeki64(input_file, remaining_z, SEEK_CUR);
 
        thread_counter++;
    }
 
saida_z:;
 
    fclose(input_file);
 
    if (retvalue_z)
    {
        return 7;
    }
 
    //exit(27);
 
    n_threads_z_14 = thread_counter;
 
    assert(cores_used_z_14);
 
    *cores_used_z_14 = n_threads_z_14;
 
    n_threads_copy = thread_counter;
 
    while (n_threads_copy--)
    {
 
        ptr_my_struct_z = calloc(1, sizeof(my_thread_struct_z));
        assert(ptr_my_struct_z);
 
        ptr_my_struct_z->thread_id_z = n_thread_counter;
 
        ptr_my_struct_z->input_file = _wfopen(utf8_2_wide_dl(input_z), L"rb");
 
        intpause_14 = 0;
        intcancel_14 = 0;
 
        ptr_my_struct_z->intpause_14 = &intpause_14;
        ptr_my_struct_z->intcancel_14 = &intcancel_14;
 
        bytes__read_thread_z_14[n_thread_counter] = 0;
 
        ptr_my_struct_z->bytes_read_z =
            &bytes__read_thread_z_14[n_thread_counter];
 
        ptr_my_struct_z->size_of_input_file_z = ptr_my_struct_z->size_of_input_file_copy_z = bytes_in_each_slice_z[n_thread_counter];
 
        ptr_my_struct_z->offset_z =
            offset_of_each_slice_z[n_thread_counter];
 
            {
                                
                void
                yasmin_charlotte_pereira_dprintf
                (
                    int amanda_level,
                    char *format, ...
                );
                // yasmin_charlotte_pereira_dprintf(0, "path temp ric -%s-", temp_path_z_14);
            // exit(27);
            // assert(0);
            }
        if (!createtempfilename_and_keep_z_12(temp_path_z_14, temp_files_z_14[n_thread_counter], "co2"))
        {
            if (0 == thread_return_value_z_14)
            {
                thread_return_value_z_14 = 407; //Cannot create temp file
            }
        }
        else
        {
            if (true)
            {
                max_memory_size_k__p_14 = 200000000 / n_threads_z_14;
 
#ifdef ARP_USE_ENHANCED_STDIO
 
                ptr_my_struct_z->dest = fopen(temp_files_z_14[n_thread_counter], "wb");
 
#else
#error stdio ric
                ptr_my_struct_z->dest = _wfopen(wpmode, L"wb");
#endif
            }
 
            if (NULL == ptr_my_struct_z->dest)
            {
                if (0 == thread_return_value_z_14)
                {
                    thread_return_value_z_14 = 405; //Cannot open output tempfile
                }
            }
        }
 
        my_thread_handle_14[n_thread_counter] = (__INT32_OR_INT64)_beginthreadex(NULL, 0, my_thread_function_v27_14, ptr_my_struct_z, 0, NULL);
 
        n_thread_counter++;
    }
 
    for (i_z = 0; i_z < n_threads_z_14; i_z++)
    {
        WaitForSingleObject((void *)my_thread_handle_14[i_z], INFINITE);
        CloseHandle((void *)my_thread_handle_14[i_z]);
    }
 
    {
 
        SetFileAttributesW(utf8_2_wide_dl(output_z), FILE_ATTRIBUTE_ARCHIVE);
 
        dest_z = _wfopen(utf8_2_wide_dl(output_z), L"wb");
 
    }
 
    if (NULL == dest_z)
    {
        if (0 == thread_return_value_z_14)
        {
            thread_return_value_z_14 = 2; //Cannot open output file
        }
    }
 
    //depois de finalizar
    for (i_z = 0; i_z < n_threads_z_14; i_z++)
    {
 
        if (dest_z)
        {
 
            if (TRUE)
            {
                max_memory_size_k__p_14 = 200000000 / n_threads_z_14;
#ifdef ARP_USE_ENHANCED_STDIO
            
                temp_z = fopen(temp_files_z_14[i_z], "rb");
 
#else
                temp_z = _wfopen(wpmode, L"rb");
#endif
            }
 
            if (temp_z)
            {
                //Mr. Do
 
            volta_amanda:;
#ifdef ARP_USE_ENHANCED_STDIO
                ret_z = fread(buffer, 1, CHUNK, temp_z);
#else
                ret_z = fread(buffer, 1, CHUNK, temp_z);
#endif
                if (0 > ret_z) //nunca vai acontecer porque é size_t...kkk
                {
                    if (0 == thread_return_value_z_14)
                    {
                        thread_return_value_z_14 = 5; //Cannot read from input file
                    }
                }
                else if (0 == ret_z)
                {
                    ; //just go by...
                }
                else
                {
 
                    ret2_z = fwrite(buffer, 1, ret_z, dest_z);
 
                    if (ret2_z != ret_z)
                    {
                        if (0 == thread_return_value_z_14)
                        {
                            assert(0 && "aqui ok");
                            thread_return_value_z_14 = 6; //Cannot write to output file
                        }
                        goto exit_loop_z;
                    }
 
                    goto volta_amanda;
                }
 
            exit_loop_z:;
 
            fclose(temp_z);
            }
            else
            {
                if (0 == thread_return_value_z_14)
                {
                    thread_return_value_z_14 = 405; //Cannot open temp file
                }
            }
        }
 
        unlink(temp_files_z_14[i_z]);
 
    }
 
    //precisa setar isto antes de retornar
    finished_14 = 1; //e depois return
 
    if (dest_z)
    {
        fclose(dest_z);
    }
    intstatus_14 = 0;
    return thread_return_value_z_14;
 
    exit(27);
    return 0;
}