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
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 0x0008
/* Has the thread enabled cancellation? */
#define PTHREAD_ATTR_FLAG_CANCEL_ENABLE 0x0010
/* Has the thread asyncronous cancellation? */
#define PTHREAD_ATTR_FLAG_CANCEL_ASYNCRONOUS 0x0020
/* Has the thread a cancellation handler? */
#define PTHREAD_ATTR_FLAG_CANCEL_HANDLER 0x0040
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
#if defined(__TERMUX__)
#include
#include
#include
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);
}
r
