/* Copyright (c) 2011-2012, The Linux Foundation. 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.
* * Neither the name of The Linux Foundation nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED "AS IS" AND ANY EXPRESS OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT
* 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.
*/
//#define ALOG_NDEBUG 0
#define ALOG_NIDEBUG 0
#define LOG_TAG "QCameraMjpegDecode"
#include <utils/Log.h>
#include <stdio.h>
#include <stdlib.h>
#include <pthread.h>
extern "C" {
#include "jpeg_buffer.h"
#include "jpeg_common.h"
#include "jpegd.h"
}
#include "QCameraMjpegDecode.h"
/* TBDJ: Can be removed */
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
// Abstract the return type of the function to be run as a thread
#define OS_THREAD_FUNC_RET_T void *
// Abstract the argument type to the thread function
#define OS_THREAD_FUNC_ARG_T void *
// Helpful constants for return values in the thread functions
#define OS_THREAD_FUNC_RET_SUCCEEDED (OS_THREAD_FUNC_RET_T)0
#define OS_THREAD_FUNC_RET_FAILED (OS_THREAD_FUNC_RET_T)1
// Abstract the function modifier placed in the beginning of the thread
// declaration (empty for Linux)
#define OS_THREAD_FUNC_MODIFIER
#define os_mutex_init(a) pthread_mutex_init(a, NULL)
#define os_cond_init(a) pthread_cond_init(a, NULL)
#define os_mutex_lock pthread_mutex_lock
#define os_mutex_unlock pthread_mutex_unlock
#define os_cond_wait pthread_cond_wait
#define os_cond_signal pthread_cond_signal
const char event_to_string[4][14] =
{
"EVENT_DONE",
"EVENT_WARNING",
"EVENT_ERROR",
};
typedef struct
{
uint32_t width;
uint32_t height;
uint32_t format;
uint32_t preference;
uint32_t abort_time;
uint16_t back_to_back_count;
/* TBDJ: Is this required */
int32_t rotation;
/* TBDJ: Is this required */
jpeg_rectangle_t region;
/* TBDJ: Is this required */
jpegd_scale_type_t scale_factor;
uint32_t hw_rotation;
char* inputMjpegBuffer;
int inputMjpegBufferSize;
char* outputYptr;
char* outputUVptr;
} test_args_t;
typedef struct
{
int tid;
pthread_t thread;
jpegd_obj_t decoder;
uint8_t decoding;
uint8_t decode_success;
pthread_mutex_t mutex;
pthread_cond_t cond;
test_args_t *p_args;
jpegd_output_buf_t *p_whole_output_buf;
} thread_ctrl_blk_t;
OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T p_thread_args);
void decoder_event_handler(void *p_user_data,
jpeg_event_t event,
void *p_arg);
int decoder_output_handler(void *p_user_data,
jpegd_output_buf_t *p_output_buffer,
uint32_t first_row_id,
uint8_t is_last_buffer);
uint32_t decoder_input_req_handler(void *p_user_data,
jpeg_buffer_t buffer,
uint32_t start_offset,
uint32_t length);
static void* insertHuffmanTable(void *p, int size);
static int mjpegd_timer_start(timespec *p_timer);
static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start);
static int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms);
// Global variables
/* TBDJ: can be removed */
thread_ctrl_blk_t *thread_ctrl_blks = NULL;
/*
* This function initializes the mjpeg decoder and returns the object
*/
MJPEGD_ERR mjpegDecoderInit(void** mjpegd_obj)
{
test_args_t* mjpegd;
ALOGD("%s: E", __func__);
mjpegd = (test_args_t *)malloc(sizeof(test_args_t));
if(!mjpegd)
return MJPEGD_INSUFFICIENT_MEM;
memset(mjpegd, 0, sizeof(test_args_t));
/* Defaults */
/* Due to current limitation, s/w decoder is selected always */
mjpegd->preference = JPEG_DECODER_PREF_HW_ACCELERATED_PREFERRED;
mjpegd->back_to_back_count = 1;
mjpegd->rotation = 0;
mjpegd->hw_rotation = 0;
mjpegd->scale_factor = (jpegd_scale_type_t)1;
/* TBDJ: can be removed */
mjpegd->width = 640;
mjpegd->height = 480;
mjpegd->abort_time = 0;
*mjpegd_obj = (void *)mjpegd;
ALOGD("%s: X", __func__);
return MJPEGD_NO_ERROR;
}
MJPEGD_ERR mjpegDecode(
void* mjpegd_obj,
char* inputMjpegBuffer,
int inputMjpegBufferSize,
char* outputYptr,
char* outputUVptr,
int outputFormat)
{
int rc, c, i;
test_args_t* mjpegd;
test_args_t test_args;
ALOGD("%s: E", __func__);
/* store input arguments in the context */
mjpegd = (test_args_t*) mjpegd_obj;
mjpegd->inputMjpegBuffer = inputMjpegBuffer;
mjpegd->inputMjpegBufferSize = inputMjpegBufferSize;
mjpegd->outputYptr = outputYptr;
mjpegd->outputUVptr = outputUVptr;
mjpegd->format = outputFormat;
/* TBDJ: can be removed */
memcpy(&test_args, mjpegd, sizeof(test_args_t));
// check the formats
if (((test_args.format == YCRCBLP_H1V2) || (test_args.format == YCBCRLP_H1V2) ||
(test_args.format == YCRCBLP_H1V1) || (test_args.format == YCBCRLP_H1V1)) &&
!(test_args.preference == JPEG_DECODER_PREF_HW_ACCELERATED_ONLY)) {
ALOGE("%s:These formats are not supported by SW format %d", __func__, test_args.format);
return 1;
}
// Create thread control blocks
thread_ctrl_blks = (thread_ctrl_blk_t *)malloc( sizeof(thread_ctrl_blk_t));
if (!thread_ctrl_blks)
{
ALOGE("%s: decoder_test failed: insufficient memory in creating thread control blocks", __func__);
return 1;
}
memset(thread_ctrl_blks, 0, sizeof(thread_ctrl_blk_t));
// Initialize the blocks and kick off the threads
thread_ctrl_blks[i].tid = i;
thread_ctrl_blks[i].p_args = &test_args;
os_mutex_init(&thread_ctrl_blks[i].mutex);
os_cond_init(&thread_ctrl_blks[i].cond);
rc = (int)decoder_test(&thread_ctrl_blks[i]);
if (!rc)
ALOGD("%s: decoder_test finished successfully ", __func__);
else
ALOGE("%s: decoder_test failed",__func__);
ALOGD("%s: X rc: %d", __func__, rc);
return rc;
}
OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER decoder_test(OS_THREAD_FUNC_ARG_T arg)
{
int rc, i;
jpegd_obj_t decoder;
jpegd_src_t source;
jpegd_dst_t dest;
jpegd_cfg_t config;
jpeg_hdr_t header;
jpegd_output_buf_t p_output_buffers;
uint32_t output_buffers_count = 1; // currently only 1 buffer a time is supported
uint8_t use_pmem = true;
timespec os_timer;
thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)arg;
test_args_t *p_args = p_thread_arg->p_args;
uint32_t output_width;
uint32_t output_height;
uint32_t total_time = 0;
ALOGD("%s: E", __func__);
// Determine whether pmem should be used (useful for pc environment testing where
// pmem is not available)
if ((jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_PREFERRED ||
(jpegd_preference_t)p_args->preference == JPEG_DECODER_PREF_SOFTWARE_ONLY) {
use_pmem = false;
}
if (((jpegd_preference_t)p_args->preference !=
JPEG_DECODER_PREF_HW_ACCELERATED_ONLY) &&
((jpegd_preference_t)p_args->scale_factor > 0)) {
ALOGI("%s: Setting scale factor to 1x", __func__);
}
ALOGD("%s: before jpegd_init p_thread_arg: %p", __func__, p_thread_arg);
// Initialize decoder
rc = jpegd_init(&decoder,
&decoder_event_handler,
&decoder_output_handler,
p_thread_arg);
if (JPEG_FAILED(rc)) {
ALOGE("%s: decoder_test: jpegd_init failed", __func__);
goto fail;
}
p_thread_arg->decoder = decoder;
// Set source information
source.p_input_req_handler = &decoder_input_req_handler;
source.total_length = p_args->inputMjpegBufferSize & 0xffffffff;
rc = jpeg_buffer_init(&source.buffers[0]);
if (JPEG_SUCCEEDED(rc)) {
/* TBDJ: why buffer [1] */
rc = jpeg_buffer_init(&source.buffers[1]);
}
if (JPEG_SUCCEEDED(rc)) {
#if 1
rc = jpeg_buffer_allocate(source.buffers[0], 0xA000, use_pmem);
#else
rc = jpeg_buffer_use_external_buffer(source.buffers[0],
(uint8_t *)p_args->inputMjpegBuffer,
p_args->inputMjpegBufferSize,
0);
#endif
ALOGD("%s: source.buffers[0]:%p compressed buffer ptr = %p", __func__,
source.buffers[0], p_args->inputMjpegBuffer);
}
if (JPEG_SUCCEEDED(rc)) {
#if 1
rc = jpeg_buffer_allocate(source.buffers[1], 0xA000, use_pmem);
#else
rc = jpeg_buffer_use_external_buffer(source.buffers[1],
(uint8_t *)p_args->inputMjpegBuffer,
p_args->inputMjpegBufferSize,
0);
#endif
ALOGD("%s: source.buffers[1]:%p compressed buffer ptr = %p", __func__,
source.buffers[1], p_args->inputMjpegBuffer);
}
if (JPEG_FAILED(rc)) {
jpeg_buffer_destroy(&source.buffers[0]);
jpeg_buffer_destroy(&source.buffers[1]);
goto fail;
}
ALOGI("%s: *** Starting back-to-back decoding of %d frame(s)***\n",
__func__, p_args->back_to_back_count);
// Loop to perform n back-to-back decoding (to the same output file)
for(i = 0; i < p_args->back_to_back_count; i++) {
if(mjpegd_timer_start(&os_timer) < 0) {
ALOGE("%s: failed to get start time", __func__);
}
/* TBDJ: Every frame? */
ALOGD("%s: before jpegd_set_source source.p_arg:%p", __func__, source.p_arg);
rc = jpegd_set_source(decoder, &source);
if (JPEG_FAILED(rc))
{
ALOGE("%s: jpegd_set_source failed", __func__);
goto fail;
}
rc = jpegd_read_header(decoder, &header);
if (JPEG_FAILED(rc))
{
ALOGE("%s: jpegd_read_header failed", __func__);
goto fail;
}
p_args->width = header.main.width;
p_args->height = header.main.height;
ALOGD("%s: main dimension: (%dx%d) subsampling: (%d)", __func__,
header.main.width, header.main.height, (int)header.main.subsampling);
// main image decoding:
// Set destination information
dest.width = (p_args->width) ? (p_args->width) : header.main.width;
dest.height = (p_args->height) ? (p_args->height) : header.main.height;
dest.output_format = (jpeg_color_format_t) p_args->format;
dest.region = p_args->region;
// if region is defined, re-assign the output width/height
output_width = dest.width;
output_height = dest.height;
if (p_args->region.right || p_args->region.bottom)
{
if (0 == p_args->rotation || 180 == p_args->rotation)
{
output_width = MIN((dest.width),
(uint32_t)(dest.region.right - dest.region.left + 1));
output_height = MIN((dest.height),
(uint32_t)(dest.region.bottom - dest.region.top + 1));
}
// Swap output width/height for 90/270 rotation cases
else if (90 == p_args->rotation || 270 == p_args->rotation)
{
output_height = MIN((dest.height),
(uint32_t)(dest.region.right - dest.region.left + 1));
output_width = MIN((dest.width),
(uint32_t)(dest.region.bottom - dest.region.top + 1));
}
// Unsupported rotation cases
else
{
goto fail;
}
}
if (dest.output_format == YCRCBLP_H2V2 || dest.output_format == YCBCRLP_H2V2 ||
dest.output_format == YCRCBLP_H2V1 || dest.output_format == YCBCRLP_H2V1 ||
dest.output_format == YCRCBLP_H1V2 || dest.output_format == YCBCRLP_H1V2 ||
dest.output_format == YCRCBLP_H1V1 || dest.output_format == YCBCRLP_H1V1) {
jpeg_buffer_init(&p_output_buffers.data.yuv.luma_buf);
jpeg_buffer_init(&p_output_buffers.data.yuv.chroma_buf);
} else {
jpeg_buffer_init(&p_output_buffers.data.rgb.rgb_buf);
}
{
// Assign 0 to tile width and height
// to indicate that no tiling is requested.
p_output_buffers.tile_width = 0;
p_output_buffers.tile_height = 0;
}
p_output_buffers.is_in_q = 0;
switch (dest.output_format)
{
case YCRCBLP_H2V2:
case YCBCRLP_H2V2:
// case YCRCBLP_H2V1:
// case YCBCRLP_H2V1:
// case YCRCBLP_H1V2:
// case YCBCRLP_H1V2:
// case YCRCBLP_H1V1:
// case YCBCRLP_H1V1:
jpeg_buffer_use_external_buffer(
p_output_buffers.data.yuv.luma_buf,
(uint8_t*)p_args->outputYptr,
p_args->width * p_args->height * SQUARE(p_args->scale_factor),
0);
jpeg_buffer_use_external_buffer(
p_output_buffers.data.yuv.chroma_buf,
(uint8_t*)p_args->outputUVptr,
p_args->width * p_args->height / 2 * SQUARE(p_args->scale_factor),
0);
break;
default:
ALOGE("%s: decoder_test: unsupported output format", __func__);
goto fail;
}
// Set up configuration
memset(&config, 0, sizeof(jpegd_cfg_t));
config.preference = (jpegd_preference_t) p_args->preference;
config.decode_from = JPEGD_DECODE_FROM_AUTO;
config.rotation = p_args->rotation;
config.scale_factor = p_args->scale_factor;
config.hw_rotation = p_args->hw_rotation;
dest.back_to_back_count = p_args->back_to_back_count;
// Start decoding
p_thread_arg->decoding = true;
rc = jpegd_start(decoder, &config, &dest, &p_output_buffers, output_buffers_count);
dest.back_to_back_count--;
if(JPEG_FAILED(rc)) {
ALOGE("%s: decoder_test: jpegd_start failed (rc=%d)\n",
__func__, rc);
goto fail;
}
ALOGD("%s: decoder_test: jpegd_start succeeded", __func__);
// Do abort
if (p_args->abort_time) {
os_mutex_lock(&p_thread_arg->mutex);
while (p_thread_arg->decoding)
{
rc = mjpegd_cond_timedwait(&p_thread_arg->cond, &p_thread_arg->mutex, p_args->abort_time);
if (rc == JPEGERR_ETIMEDOUT)
{
// Do abort
os_mutex_unlock(&p_thread_arg->mutex);
rc = jpegd_abort(decoder);
if (rc)
{
ALOGE("%s: decoder_test: jpegd_abort failed: %d", __func__, rc);
goto fail;
}
break;
}
}
if (p_thread_arg->decoding)
os_mutex_unlock(&p_thread_arg->mutex);
} else {
// Wait until decoding is done or stopped due to error
os_mutex_lock(&p_thread_arg->mutex);
while (p_thread_arg->decoding)
{
os_cond_wait(&p_thread_arg->cond, &p_thread_arg->mutex);
}
os_mutex_unlock(&p_thread_arg->mutex);
}
int diff;
// Display the time elapsed
if (mjpegd_timer_get_elapsed(&os_timer, &diff, 0) < 0) {
ALOGE("%s: decoder_test: failed to get elapsed time", __func__);
} else {
if(p_args->abort_time) {
if(p_thread_arg->decoding) {
ALOGI("%s: decoder_test: decoding aborted successfully after %d ms", __func__, diff);
goto buffer_clean_up;
}
else
{
ALOGI("%s: decoder_test: decoding stopped before abort is issued. "
"decode time: %d ms", __func__, diff);
}
}
else {
if(p_thread_arg->decode_success) {
total_time += diff;
ALOGI("%s: decode time: %d ms (%d frame(s), total=%dms, avg=%dms/frame)",
__func__, diff, i+1, total_time, total_time/(i+1));
}
else
{
fprintf(stderr, "decoder_test: decode failed\n");
}
}
}
}
if(p_thread_arg->decode_success) {
ALOGD("%s: Frame(s) = %d, Total Time = %dms, Avg. decode time = %dms/frame)\n",
__func__, p_args->back_to_back_count, total_time, total_time/p_args->back_to_back_count);
}
buffer_clean_up:
// Clean up decoder and allocate buffers
jpeg_buffer_destroy(&source.buffers[0]);
jpeg_buffer_destroy(&source.buffers[1]);
switch (dest.output_format)
{
case YCRCBLP_H2V2:
case YCBCRLP_H2V2:
case YCRCBLP_H2V1:
case YCBCRLP_H2V1:
case YCRCBLP_H1V2:
case YCBCRLP_H1V2:
case YCRCBLP_H1V1:
case YCBCRLP_H1V1:
jpeg_buffer_destroy(&p_output_buffers.data.yuv.luma_buf);
jpeg_buffer_destroy(&p_output_buffers.data.yuv.chroma_buf);
break;
default:
break;
}
jpegd_destroy(&decoder);
if (!p_thread_arg->decode_success)
{
goto fail;
}
ALOGD("%s: X", __func__);
return OS_THREAD_FUNC_RET_SUCCEEDED;
fail:
ALOGD("%s: X", __func__);
return OS_THREAD_FUNC_RET_FAILED;
}
void decoder_event_handler(void *p_user_data,
jpeg_event_t event,
void *p_arg)
{
thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
ALOGD("%s: E", __func__);
ALOGD("%s: Event: %s\n", __func__, event_to_string[event]);
if (event == JPEG_EVENT_DONE)
{
p_thread_arg->decode_success = true;
ALOGD("%s: decode_success: %d\n", __func__, p_thread_arg->decode_success);
}
// If it is not a warning event, decoder has stopped; Signal
// main thread to clean up
if (event != JPEG_EVENT_WARNING)
{
os_mutex_lock(&p_thread_arg->mutex);
p_thread_arg->decoding = false;
os_cond_signal(&p_thread_arg->cond);
os_mutex_unlock(&p_thread_arg->mutex);
}
ALOGD("%s: X", __func__);
}
// consumes the output buffer.
/*TBDJ: Can be removed. Is this related to tiling */
int decoder_output_handler(void *p_user_data,
jpegd_output_buf_t *p_output_buffer,
uint32_t first_row_id,
uint8_t is_last_buffer)
{
uint8_t* whole_output_buf_ptr, *tiling_buf_ptr;
ALOGD("%s: E", __func__);
thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
jpeg_buffer_get_addr(p_thread_arg->p_whole_output_buf->data.rgb.rgb_buf, &whole_output_buf_ptr);
jpeg_buffer_get_addr(p_output_buffer->data.rgb.rgb_buf, &tiling_buf_ptr);
if (p_output_buffer->tile_height != 1)
return JPEGERR_EUNSUPPORTED;
// testing purpose only
// This is to simulate that the user needs to bail out when error happens
// in the middle of decoding
//if (first_row_id == 162)
// return JPEGERR_EFAILED;
// do not enqueue any buffer if it reaches the last buffer
if (!is_last_buffer)
{
jpegd_enqueue_output_buf(p_thread_arg->decoder, p_output_buffer, 1);
}
ALOGD("%s: X", __func__);
return JPEGERR_SUCCESS;
}
// p_reader->p_input_req_handler(p_reader->decoder,
// p_reader->p_input_buf,
// p_reader->next_byte_offset,
// MAX_BYTES_TO_FETCH);
uint32_t decoder_input_req_handler(void *p_user_data,
jpeg_buffer_t buffer,
uint32_t start_offset,
uint32_t length)
{
uint32_t buf_size;
uint8_t *buf_ptr;
int bytes_to_read, bytes_read, rc;
thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *)p_user_data;
thread_ctrl_blk_t *thread_ctrl_blk = (thread_ctrl_blk_t *)p_user_data;
test_args_t* mjpegd = (test_args_t*) thread_ctrl_blk->p_args;
ALOGD("%s: E", __func__);
jpeg_buffer_get_max_size(buffer, &buf_size);
jpeg_buffer_get_addr(buffer, &buf_ptr);
bytes_to_read = (length < buf_size) ? length : buf_size;
bytes_read = 0;
ALOGD("%s: buf_ptr = %p, start_offset = %d, length = %d buf_size = %d bytes_to_read = %d", __func__, buf_ptr, start_offset, length, buf_size, bytes_to_read);
if (bytes_to_read)
{
/* TBDJ: Should avoid this Mem copy */
#if 1
memcpy(buf_ptr, (char *)mjpegd->inputMjpegBuffer + start_offset, bytes_to_read);
#else
if(JPEGERR_SUCCESS != jpeg_buffer_set_start_offset(buffer, start_offset))
ALOGE("%s: jpeg_buffer_set_start_offset failed", __func__);
#endif
bytes_read = bytes_to_read;
}
ALOGD("%s: X", __func__);
return bytes_read;
}
static int mjpegd_timer_start(timespec *p_timer)
{
if (!p_timer)
return JPEGERR_ENULLPTR;
if (clock_gettime(CLOCK_REALTIME, p_timer))
return JPEGERR_EFAILED;
return JPEGERR_SUCCESS;
}
static int mjpegd_timer_get_elapsed(timespec *p_timer, int *elapsed_in_ms, uint8_t reset_start)
{
timespec now;
long diff;
int rc = mjpegd_timer_start(&now);
if (JPEG_FAILED(rc))
return rc;
diff = (long)(now.tv_sec - p_timer->tv_sec) * 1000;
diff += (long)(now.tv_nsec - p_timer->tv_nsec) / 1000000;
*elapsed_in_ms = (int)diff;
if (reset_start)
*p_timer = now;
return JPEGERR_SUCCESS;
}
int mjpegd_cond_timedwait(pthread_cond_t *p_cond, pthread_mutex_t *p_mutex, uint32_t ms)
{
struct timespec ts;
int rc = clock_gettime(CLOCK_REALTIME, &ts);
if (rc < 0) return rc;
if (ms >= 1000) {
ts.tv_sec += (ms/1000);
ts.tv_nsec += ((ms%1000) * 1000000);
} else {
ts.tv_nsec += (ms * 1000000);
}
rc = pthread_cond_timedwait(p_cond, p_mutex, &ts);
if (rc == ETIMEDOUT)
{
rc = JPEGERR_ETIMEDOUT;
}
return rc;
}