/****************************************************************************** * Function: jpeg_queue_reset * Description: Resets the queue object * Input parameters: * queue - The queue object to be reset. * Return values: * JPEGERR_SUCCESS * JPEGERR_ENULLPTR * Notes: none *****************************************************************************/ int jpeg_queue_reset(jpeg_queue_t queue) { jpeg_q_t *p_q = (jpeg_q_t *)queue; int rc = JPEGERR_SUCCESS; if (!p_q) { JPEG_DBG_ERROR("jpeg_queue_reset: failed with empty queue pointer\n"); return JPEGERR_ENULLPTR; } // Abort previous queue rc = jpeg_queue_abort(&queue); if (JPEG_FAILED(rc)) { JPEG_DBG_ERROR("jpeg_queue_reset: jpeg_queue_abort failed \n"); return rc; } os_mutex_lock(&(p_q->mutex)); // Initialize queue head, tail and counts all to zero p_q->queue_head = 0; p_q->queue_tail = 0; p_q->queue_cnt = 0; (void)STD_MEMSET(&(p_q->queue_pool), 0, sizeof(jpeg_queue_pool_t)); p_q->state = QUEUE_STATE_IDLE; os_mutex_unlock(&(p_q->mutex)); return JPEGERR_SUCCESS; }
OS_THREAD_FUNC_RET_T OS_THREAD_FUNC_MODIFIER hw_engine_encode (OS_THREAD_FUNC_ARG_T arg) { // char *output_filename; thread_ctrl_blk_t *p_thread_arg = (thread_ctrl_blk_t *) arg; int rc, i; jpege_obj_t encoder; jpege_src_t source; jpege_dst_t dest; jpege_cfg_t config; jpege_img_data_t img_info; //tn_img_info; jpeg_buffer_t main_luma_buf, main_chroma_buf; jpeg_buffer_t tn_luma_buf, tn_chroma_buf; encoder_args_t *p_args = p_thread_arg->p_args; uint8_t use_pmem = false; jpeg_buffer_t buffers[2]; // Append the output file name with a number to avoid multiple writing to the same file #if 0 if (p_thread_arg->tid) { // Look for the last occurence of '/' and then last occurence of '.' char *s = strrchr (p_args->output_file, '/'); if (s) { s = strrchr (s, '.'); } else { s = strrchr (p_args->output_file, '.'); } output_filename = (char *) malloc (5 + strlen (p_args->output_file)); sLOG_D (output_filename, "%s", p_args->output_file); if (s) { sLOG_D (output_filename + (s - p_args->output_file), "_%.2d%s", p_thread_arg->tid, s); } else { sLOG_D (output_filename, "%s_%.2d", output_filename, p_thread_arg->tid); } } #endif // Determine whether pmem should be used (useful for pc environment testing where // pmem is not available) use_pmem = p_args->use_pmem; if ((jpege_preference_t) p_args->preference == JPEG_ENCODER_PREF_SOFTWARE_PREFERRED || (jpege_preference_t) p_args->preference == JPEG_ENCODER_PREF_SOFTWARE_ONLY) { use_pmem = false; } // Initialize source buffers if (jpeg_buffer_init (&main_luma_buf) || jpeg_buffer_init (&main_chroma_buf) || jpeg_buffer_init (&tn_luma_buf) || jpeg_buffer_init (&tn_chroma_buf)) { return OS_THREAD_FUNC_RET_FAILED; } // Open input file(s) and read the contents if (p_args->main.format == YCBCRLP_H2V2 || p_args->main.format == YCRCBLP_H2V2) { if (read_bytes_from_buffer (p_args->main.width, p_args->main.height, &main_luma_buf, &main_chroma_buf, use_pmem, p_args, false)) return OS_THREAD_FUNC_RET_FAILED; } #if 0 else if ((p_args->main.format >= JPEG_BITSTREAM_H2V2) && (p_args->main.format < JPEG_COLOR_FORMAT_MAX)) { if (read_bs_from_file (p_args->main.file_name, p_args->main.width, p_args->main.height, &main_luma_buf, use_pmem)) return OS_THREAD_FUNC_RET_FAILED; } #endif else { LOG_D ("hw_engine_encode: main inage color format not supported\n"); return OS_THREAD_FUNC_RET_FAILED; } #if 0 if (p_args->encode_thumbnail) { if (p_args->thumbnail.format <= YCBCRLP_H1V1) { if (read_bytes_from_buffer (p_args->thumbnail.width, p_args->thumbnail.height, &tn_luma_buf, &tn_chroma_buf, use_pmem, p_args, true)) return OS_THREAD_FUNC_RET_FAILED; } else if ((p_args->thumbnail.format >= JPEG_BITSTREAM_H2V2) && (p_args->main.format < JPEG_COLOR_FORMAT_MAX)) { if (read_bs_from_file (p_args->thumbnail.file_name, p_args->thumbnail.width, p_args->thumbnail.height, &tn_luma_buf, use_pmem)) return OS_THREAD_FUNC_RET_FAILED; } else { LOG_D ("hw_engine_encode: thumbnail color format not supported\n"); return OS_THREAD_FUNC_RET_FAILED; } } #endif // Initialize encoder rc = jpege_init (&encoder, &encoder_event_handler,(void *) p_thread_arg); if (JPEG_FAILED (rc)) { LOG_D ("hw_engine_encode: jpege_init failed\n"); return OS_THREAD_FUNC_RET_FAILED; } p_thread_arg->encoder = encoder; // Set source information (main) img_info.color_format = p_args->main.format; img_info.width = p_args->main.width; img_info.height = p_args->main.height; img_info.fragment_cnt = 1; img_info.p_fragments[0].width = p_args->main.width; img_info.p_fragments[0].height = p_args->main.height; // if (img_info.color_format <= YCBCRLP_H1V1) { img_info.p_fragments[0].color.yuv.luma_buf = main_luma_buf; img_info.p_fragments[0].color.yuv.chroma_buf = main_chroma_buf; } #if 0 else if ((img_info.color_format >= JPEG_BITSTREAM_H2V2) &&
/****************************************************************************** * Function: jpeg_queue_dequeue * Description: Dequeue a entry from the queue. It returns the double pointer * to the entry to be denqueued from the head of queue, * and accepts the number of time in mini-seconds that it conditional . * waits if the queue if empty. * Input parameters: * queue - The queue object. * pp_dequeue_buffer - The double pointer to dequeued entry. * ms - The time out in minisecond * Return values: * JPEGERR_SUCCESS * JPEGERR_EFAILED * JPEGERR_ENULLPTR * JPEGERR_ETIMEDOUT * Notes: none *****************************************************************************/ int jpeg_queue_dequeue( jpeg_queue_t queue, void **pp_dequeue_entry, uint32_t time_out_ms) { uint32_t q_index; jpeg_q_t *p_q; int rc; // Input parameter validation if (!pp_dequeue_entry) { JPEG_DBG_ERROR("jpeg_queue_dequeue: failed with input parameter check\n"); return JPEGERR_EBADPARM; } p_q = (jpeg_q_t *)queue; if (!p_q) { JPEG_DBG_ERROR("jpeg_queue_dequeue: failed with empty queue pointer\n"); return JPEGERR_ENULLPTR; } os_mutex_lock(&(p_q->mutex)); if (p_q->state == QUEUE_STATE_ABORTED) { os_mutex_unlock(&(p_q->mutex)); JPEG_DBG_ERROR("jpeg_queue_dequeue: Aborted \n"); return JPEGERR_EFAILED; } // Check if queue is empty: // queue_cnt is current number of entries in queue. while (p_q->queue_cnt <= 0 && QUEUE_STATE_ABORT != p_q->state) { p_q->state = QUEUE_STATE_TIMEWAIT; // fails after conditional waiting time_out_ms in milli-seconds rc = os_cond_timedwait(&(p_q->get_cond), &(p_q->mutex), time_out_ms); if (JPEG_FAILED(rc)) { JPEG_DBG_ERROR("jpeg_queue_dequeue: failed with empty queue\n"); if (QUEUE_STATE_ABORT == p_q->state) { p_q->state = QUEUE_STATE_ABORTED; os_cond_signal(&(p_q->abort_cond)); } p_q->state = QUEUE_STATE_IDLE; os_mutex_unlock(&(p_q->mutex)); return rc; } } if (QUEUE_STATE_ABORT == p_q->state) { p_q->state = QUEUE_STATE_IDLE; // signal abort cond os_cond_signal(&(p_q->abort_cond)); os_mutex_unlock(&(p_q->mutex)); JPEG_DBG_ERROR("jpeg_queue_dequeue: failed with abort\n"); return JPEGERR_EFAILED; } // Dequeue an entry from queue q_index = p_q->queue_head; // Dequeue the entry from the head of queue *pp_dequeue_entry = p_q->queue_pool[q_index].p_data; // Update the head of queue and entries number p_q->queue_head = QUEUE_MOD(p_q->queue_head + 1); p_q->queue_cnt -= 1; p_q->state = QUEUE_STATE_IDLE; os_mutex_unlock(&(p_q->mutex)); return JPEGERR_SUCCESS; }