Not really full patch, but just something I hacked together for compiling cinelerra-gg on termux (linux terminal emulator AND distribution for running on Android 7+ devices).
I wonder if this functionality can be (or should) be rolled into mjpegtools ? Or it better remain as separate patch for termux-packages repo? libbthread from https://github.com/tux-mind/libbthread
mjpegtools-2.1.0.patch6
Description: Binary data
mjpegtools-2.1.0.patch7
Description: Binary data
mjpegtools-2.1.0.patch4
Description: Binary data
mjpegtools-2.1.0.patch5
Description: Binary data
/*
* Copyright (C) 2008 The Android Open Source Project
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * 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 _PTHREAD_INTERNAL_H_
#define _PTHREAD_INTERNAL_H_
#include <pthread.h>
struct pthread_internal_t {
struct pthread_internal_t* next;
struct pthread_internal_t* prev;
pid_t tid;
void** tls;
volatile pthread_attr_t attr;
__pthread_cleanup_t* cleanup_stack;
void* (*start_routine)(void*);
void* start_routine_arg;
void* return_value;
void* alternate_signal_stack;
/*
* The dynamic linker implements dlerror(3), which makes it hard for us to implement this
* per-thread buffer by simply using malloc(3) and free(3).
*/
#define __BIONIC_DLERROR_BUFFER_SIZE 508
char dlerror_buffer[__BIONIC_DLERROR_BUFFER_SIZE];
// ugly hack: use last 4 bytes of dlerror_buffer as cancel_lock
pthread_mutex_t cancel_lock;
};
/* Has the thread a cancellation request? */
#define PTHREAD_ATTR_FLAG_CANCEL_PENDING 0x00000008
/* Has the thread enabled cancellation? */
#define PTHREAD_ATTR_FLAG_CANCEL_ENABLE 0x00000010
/* Has the thread asyncronous cancellation? */
#define PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS 0x00000020
/* Has the thread a cancellation handler? */
#define PTHREAD_ATTR_FLAG_CANCEL_HANDLER 0x00000040
struct pthread_internal_t *__pthread_getid ( pthread_t );
int __pthread_do_cancel (struct pthread_internal_t *);
void pthread_init(void);
#endif /* _PTHREAD_INTERNAL_H_ */
/* Cancel a thread.
Copyright (C) 2002 Free Software Foundation, Inc.
This file is part of the GNU C Library.
The GNU C Library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
The GNU C Library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
Library General Public License for more details.
You should have received a copy of the GNU Library General Public
License along with the GNU C Library; see the file COPYING.LIB. If not,
write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA. */
#include <stdio.h>
#if defined(__TERMUX__)
#include <pthread.h>
#include <pt-internal.h>
#include <errno.h>
int
pthread_cancel (pthread_t t)
{
int err = 0;
struct pthread_internal_t *p = (struct pthread_internal_t*) t;
pthread_init();
pthread_mutex_lock (&p->cancel_lock);
if (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_PENDING)
{
pthread_mutex_unlock (&p->cancel_lock);
return 0;
}
p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_PENDING;
if (!(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE))
{
pthread_mutex_unlock (&p->cancel_lock);
return 0;
}
if (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS) {
pthread_mutex_unlock (&p->cancel_lock);
err = __pthread_do_cancel (p);
} else {
// DEFERRED CANCEL NOT IMPLEMENTED YET
pthread_mutex_unlock (&p->cancel_lock);
}
return err;
}
/* Cancel a thread. */
#include <pthread.h>
#include <pt-internal.h>
static void
call_exit (void)
{
pthread_exit (0);
}
int
__pthread_do_cancel (struct pthread_internal_t *p)
{
if(p == (struct pthread_internal_t *)pthread_self())
call_exit ();
else if(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_HANDLER)
pthread_kill((pthread_t)p, SIGRTMIN);
else
pthread_kill((pthread_t)p, SIGTERM);
return 0;
}
/* Init a thread. */
#include <pthread.h>
#include <bthread.h>
#include <pt-internal.h>
#include <signal.h>
void pthread_cancel_handler(int signum) {
pthread_exit(0);
}
void pthread_init(void) {
struct sigaction sa;
struct pthread_internal_t * p = (struct pthread_internal_t *)pthread_self();
if(p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_HANDLER)
return;
// set thread status as pthread_create should do.
// ASYNCROUNOUS is not set, see pthread_setcancelstate(3)
p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_HANDLER|PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
sa.sa_handler = pthread_cancel_handler;
sigemptyset(&(sa.sa_mask));
sa.sa_flags = 0;
sigaction(SIGRTMIN, &sa, NULL);
}
/* Set the cancel state for the calling thread. */
#include <pthread.h>
#include <bthread.h>
#include <pt-internal.h>
#include <errno.h>
int
pthread_setcancelstate (int state, int *oldstate)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int newflags;
pthread_init();
switch (state)
{
default:
return EINVAL;
case PTHREAD_CANCEL_ENABLE:
case PTHREAD_CANCEL_DISABLE:
break;
}
pthread_mutex_lock (&p->cancel_lock);
if (oldstate)
*oldstate = p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
if(state == PTHREAD_ATTR_FLAG_CANCEL_ENABLE)
p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
else
p->attr.flags &= ~PTHREAD_ATTR_FLAG_CANCEL_ENABLE;
newflags=p->attr.flags;
pthread_mutex_unlock (&p->cancel_lock);
if((newflags & PTHREAD_ATTR_FLAG_CANCEL_PENDING) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS))
__pthread_do_cancel(p);
return 0;
}
/* */
#include <pthread.h>
#include <bthread.h>
#include <pt-internal.h>
#include <errno.h>
int
pthread_setcanceltype (int type, int *oldtype)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int newflags;
pthread_init();
switch (type)
{
default:
return EINVAL;
case PTHREAD_CANCEL_DEFERRED:
case PTHREAD_CANCEL_ASYNCHRONOUS:
break;
}
pthread_mutex_lock (&p->cancel_lock);
if (oldtype)
*oldtype = p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
if(type == PTHREAD_CANCEL_ASYNCHRONOUS)
p->attr.flags |= PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
else
p->attr.flags &= ~PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS;
newflags=p->attr.flags;
pthread_mutex_unlock (&p->cancel_lock);
if((newflags & PTHREAD_ATTR_FLAG_CANCEL_PENDING) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (newflags & PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS))
__pthread_do_cancel(p);
return 0;
}
/* Add an explicit cancelation point. */
#include <pthread.h>
#include <bthread.h>
#include <pt-internal.h>
void
pthread_testcancel (void)
{
struct pthread_internal_t *p = (struct pthread_internal_t*)pthread_self();
int cancelled;
pthread_init();
pthread_mutex_lock (&p->cancel_lock);
cancelled = (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_ENABLE) && (p->attr.flags & PTHREAD_ATTR_FLAG_CANCEL_PENDING);
pthread_mutex_unlock (&p->cancel_lock);
if (cancelled)
pthread_exit (PTHREAD_CANCELED);
}
#endif
libbthread
==========
library that provide some missing posix threading function to the bionic libc.
while i was porting tens of linux projects under the dSploit android app i found that
the bionic libc does not provide some POSIX thread functions like `pthread_cancel`, `pthread_testcancel` and so on.
so, i developed this library, which exploit some unused bits in the bionic thread structure.
there is many thing to develop, like support for deferred cancels, but basic thread cancellation works :smiley:
i hope that you find this library useful :wink:
-- tux_mind
License
==========
Project is licensed under GNU LGPL v2.0 (Library General Public License)
pt-internal.h - is from The Android Open Source Project and licensed under Apache License, Version 2.0
building
========
```bash
$ autoreconf -i
$ export PATH="$PATH:/path/to/ndk/toolchains/llvm/prebuilt/linux-x86_64/bin"
$ target_host=aarch64-linux-android
$ export AR=${target_host}-ar
$ export AS=${target_host}-as
$ export CC=${target_host}21-clang
$ export CXX=${target_host}21-clang++
$ export LD=${target_host}-ld
$ export STRIP=${target_host}-strip
$ export CFLAGS="-fPIE -fPIC"
$ export LDFLAGS="-pie"
$ ./configure --host=${target_host}
$ make
```
_______________________________________________ Mjpeg-users mailing list Mjpeg-users@lists.sourceforge.net https://lists.sourceforge.net/lists/listinfo/mjpeg-users
