void * Block_Down_Sample<T, N>::thread_worker(void * arg) {
	co_index my_entr = (((pthread_arg * )arg)->entr);
	Block_Down_Sample * c = (Block_Down_Sample *) ((pthread_arg * )arg)->call_class;

	if (my_entr[0] + c->B - 1 >= c->D[0]) {
		pthread_exit(NULL);
	}

	co_index OUT_entr;
	for (int i = 0; i < N; ++i)	{
		OUT_entr[i] = my_entr[i] / c->B;
	}
	c->OUT(OUT_entr) = c->most_com_from_sub_img(my_entr);
	((pthread_arg * )arg)->entr = c->counter_to_co_index(my_entr, c->B * c->M_thread);

	thread_worker(arg);   
};
    ThreadPoolPosix(std::size_t num_threads,
                    std::size_t task_capacity)
            :
            m_cancelled(false)
    {
        // Creates the message queues (in/out) for the tasks:
        m_input_queue.reset(IMessageQueue::create(task_capacity));
        m_output_queue.reset(IMessageQueue::create());

        // Creates the threads:
        m_threads.reserve(num_threads);
        for (std::size_t i = 0; i < num_threads; ++i)
        {
            Task worker(new ThreadPoolWorker(*m_input_queue,
                                             *m_output_queue));

            Thread thread_worker(IThread::create(worker));
            m_threads.push_back(thread_worker);
        }
    }