thread.h

Go to the documentation of this file.

/*
 * The copyright in this software is being made available under the 2-clauses
 * BSD License, included below. This software may be subject to other third
 * party and contributor rights, including patent rights, and no such rights
 * are granted under this license.
 *
 * Copyright (c) 2016, Even Rouault
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS `AS IS'
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
 * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */
 
#ifndef THREAD_H
#define THREAD_H
 
#include "openjpeg.h"
 
 
 
typedef struct opj_mutex_t opj_mutex_t;
 
opj_mutex_t* opj_mutex_create(void);
 
void opj_mutex_lock(opj_mutex_t* mutex);
 
void opj_mutex_unlock(opj_mutex_t* mutex);
 
void opj_mutex_destroy(opj_mutex_t* mutex);
 
 
typedef struct opj_cond_t opj_cond_t;
 
opj_cond_t* opj_cond_create(void);
 
void opj_cond_wait(opj_cond_t* cond, opj_mutex_t* mutex);
 
void opj_cond_signal(opj_cond_t* cond);
 
void opj_cond_destroy(opj_cond_t* cond);
 
 
typedef struct opj_thread_t opj_thread_t;
 
typedef void (*opj_thread_fn)(void* user_data);
 
opj_thread_t* opj_thread_create(opj_thread_fn thread_fn, void* user_data);
 
void opj_thread_join(opj_thread_t* thread);
 
typedef struct opj_tls_t opj_tls_t;
 
void* opj_tls_get(opj_tls_t* tls, int key);
 
typedef void (*opj_tls_free_func)(void* value);
 
OPJ_BOOL opj_tls_set(opj_tls_t* tls, int key, void* value,
                     opj_tls_free_func free_func);
 
 
typedef struct opj_thread_pool_t opj_thread_pool_t;
 
opj_thread_pool_t* opj_thread_pool_create(int num_threads);
 
typedef void (*opj_job_fn)(void* user_data, opj_tls_t* tls);
 
 
OPJ_BOOL opj_thread_pool_submit_job(opj_thread_pool_t* tp, opj_job_fn job_fn,
                                    void* user_data);
 
void opj_thread_pool_wait_completion(opj_thread_pool_t* tp,
                                     int max_remaining_jobs);
 
int opj_thread_pool_get_thread_count(opj_thread_pool_t* tp);
 
void opj_thread_pool_destroy(opj_thread_pool_t* tp);
 
 
#endif /* THREAD_H */