ImxVpuDecReturnCodes imx_vpu_dec_close(ImxVpuDecoder *decoder)
{
VpuDecRetCode ret;
IMX_VPU_TRACE("closing decoder");
ret = VPU_DecFlushAll(decoder->handle);
if (ret == VPU_DEC_RET_FAILURE_TIMEOUT)
{
IMX_VPU_WARNING("resetting decoder after a timeout occurred");
ret = VPU_DecReset(decoder->handle);
if (ret != VPU_DEC_RET_SUCCESS)
IMX_VPU_ERROR("resetting decoder failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
}
else if (ret != VPU_DEC_RET_SUCCESS)
IMX_VPU_ERROR("flushing decoder failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
ret = VPU_DecClose(decoder->handle);
if (ret != VPU_DEC_RET_SUCCESS)
IMX_VPU_ERROR("closing decoder failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
if (decoder->user_data_for_frames != NULL)
IMX_VPU_FREE(decoder->user_data_for_frames, sizeof(void*) * decoder->num_framebuffers);
if (decoder->wrapper_framebuffers != NULL)
IMX_VPU_FREE(decoder->wrapper_framebuffers, sizeof(VpuFrameBuffer*) * decoder->num_framebuffers);
if (decoder->virt_mem_sub_block != NULL)
IMX_VPU_FREE(decoder->virt_mem_sub_block, decoder->virt_mem_sub_block_size);
IMX_VPU_FREE(decoder, sizeof(ImxVpuDecoder));
IMX_VPU_TRACE("closed decoder");
return dec_convert_retcode(ret);
}
ImxVpuDecReturnCodes imx_vpu_dec_register_framebuffers(ImxVpuDecoder *decoder, ImxVpuFramebuffer *framebuffers, unsigned int num_framebuffers)
{
unsigned int i;
VpuDecRetCode ret;
VpuFrameBuffer *temp_fbs;
IMX_VPU_TRACE("attempting to register %u framebuffers", num_framebuffers);
decoder->wrapper_framebuffers = NULL;
temp_fbs = IMX_VPU_ALLOC(sizeof(VpuFrameBuffer) * num_framebuffers);
if (temp_fbs == NULL)
{
IMX_VPU_ERROR("allocating memory for framebuffers failed");
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
for (i = 0; i < num_framebuffers; ++i)
convert_to_wrapper_framebuffer(&framebuffers[i], &(temp_fbs[i]));
ret = VPU_DecRegisterFrameBuffer(decoder->handle, temp_fbs, num_framebuffers);
IMX_VPU_FREE(temp_fbs, sizeof(VpuFrameBuffer) * num_framebuffers);
if (ret != VPU_DEC_RET_SUCCESS)
{
ImxVpuDecReturnCodes imxret = dec_convert_retcode(ret);
IMX_VPU_ERROR("registering framebuffers failed: %s", imx_vpu_dec_error_string(imxret));
return ret;
}
decoder->wrapper_framebuffers = IMX_VPU_ALLOC(sizeof(VpuFrameBuffer*) * num_framebuffers);
{
int out_num;
VPU_DecAllRegFrameInfo(decoder->handle, decoder->wrapper_framebuffers, &out_num);
IMX_VPU_LOG("out_num: %d num_framebuffers: %u", out_num, num_framebuffers);
}
decoder->framebuffers = framebuffers;
decoder->num_framebuffers = num_framebuffers;
decoder->num_available_framebuffers = num_framebuffers;
decoder->user_data_for_frames = IMX_VPU_ALLOC(sizeof(void*) * num_framebuffers);
if (decoder->user_data_for_frames == NULL)
{
IMX_VPU_ERROR("allocating memory for user data failed");
IMX_VPU_FREE(decoder->wrapper_framebuffers, sizeof(VpuFrameBuffer*) * num_framebuffers);
decoder->wrapper_framebuffers = NULL;
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
memset(decoder->user_data_for_frames, 0, sizeof(void*) * num_framebuffers);
decoder->num_user_data = 0;
return IMX_VPU_DEC_RETURN_CODE_OK;
}
static void imx_vpu_jpeg_enc_deallocate_framebuffers(ImxVpuJPEGEncoder *jpeg_encoder)
{
assert(jpeg_encoder != NULL);
if (jpeg_encoder->framebuffers != NULL)
{
IMX_VPU_FREE(jpeg_encoder->framebuffers, sizeof(ImxVpuFramebuffer) * jpeg_encoder->num_framebuffers);
jpeg_encoder->framebuffers = NULL;
}
if (jpeg_encoder->fb_dmabuffers != NULL)
{
imx_vpu_jpeg_deallocate_dma_buffers(jpeg_encoder->fb_dmabuffers, jpeg_encoder->num_framebuffers);
IMX_VPU_FREE(jpeg_encoder->fb_dmabuffers, sizeof(ImxVpuDMABuffer *) * jpeg_encoder->num_framebuffers);
jpeg_encoder->fb_dmabuffers = NULL;
}
}
ImxVpuDecReturnCodes imx_vpu_jpeg_dec_open(ImxVpuJPEGDecoder **jpeg_decoder, ImxVpuDMABufferAllocator *dma_buffer_allocator, unsigned int num_extra_framebuffers)
{
ImxVpuDecOpenParams open_params;
ImxVpuDecReturnCodes ret = IMX_VPU_DEC_RETURN_CODE_OK;
ImxVpuJPEGDecoder *jpegdec = NULL;
assert(jpeg_decoder != NULL);
if ((ret = imx_vpu_dec_load()) != IMX_VPU_DEC_RETURN_CODE_OK)
return ret;
jpegdec = IMX_VPU_ALLOC(sizeof(ImxVpuJPEGDecoder));
if (jpegdec == NULL)
{
IMX_VPU_ERROR("allocating memory for JPEG decoder object failed");
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
memset(jpegdec, 0, sizeof(ImxVpuJPEGDecoder));
jpegdec->dma_buffer_allocator = (dma_buffer_allocator != NULL) ? dma_buffer_allocator : imx_vpu_dec_get_default_allocator();
jpegdec->num_extra_framebuffers = num_extra_framebuffers;
memset(&open_params, 0, sizeof(open_params));
open_params.codec_format = IMX_VPU_CODEC_FORMAT_MJPEG;
open_params.frame_width = 0;
open_params.frame_height = 0;
imx_vpu_dec_get_bitstream_buffer_info(&(jpegdec->bitstream_buffer_size), &(jpegdec->bitstream_buffer_alignment));
jpegdec->bitstream_buffer = imx_vpu_dma_buffer_allocate(jpegdec->dma_buffer_allocator, jpegdec->bitstream_buffer_size, jpegdec->bitstream_buffer_alignment, 0);
if (jpegdec->bitstream_buffer == NULL)
{
IMX_VPU_ERROR("could not allocate DMA buffer for bitstream buffer with %u bytes and alignment %u", jpegdec->bitstream_buffer_size, jpegdec->bitstream_buffer_alignment);
ret = IMX_VPU_DEC_RETURN_CODE_ERROR;
goto error;
}
if ((ret = imx_vpu_dec_open(&(jpegdec->decoder), &open_params, jpegdec->bitstream_buffer, initial_info_callback, jpegdec)) != IMX_VPU_DEC_RETURN_CODE_OK)
goto error;
*jpeg_decoder = jpegdec;
return IMX_VPU_DEC_RETURN_CODE_OK;
error:
if (jpegdec != NULL)
{
if (jpegdec->bitstream_buffer != NULL)
imx_vpu_dma_buffer_deallocate(jpegdec->bitstream_buffer);
IMX_VPU_FREE(jpegdec, sizeof(ImxVpuJPEGDecoder));
}
return ret;
}
ImxVpuEncReturnCodes imx_vpu_jpeg_enc_close(ImxVpuJPEGEncoder *jpeg_encoder)
{
assert(jpeg_encoder != NULL);
imx_vpu_jpeg_enc_close_internal(jpeg_encoder);
if (jpeg_encoder->bitstream_buffer != NULL)
imx_vpu_dma_buffer_deallocate(jpeg_encoder->bitstream_buffer);
imx_vpu_enc_unload();
IMX_VPU_FREE(jpeg_encoder, sizeof(ImxVpuJPEGEncoder));
return IMX_VPU_ENC_RETURN_CODE_OK;
}
ImxVpuDecReturnCodes imx_vpu_jpeg_dec_close(ImxVpuJPEGDecoder *jpeg_decoder)
{
assert(jpeg_decoder != NULL);
assert(jpeg_decoder->decoder != NULL);
imx_vpu_dec_close(jpeg_decoder->decoder);
imx_vpu_jpeg_dec_deallocate_framebuffers(jpeg_decoder);
if (jpeg_decoder->bitstream_buffer != NULL)
imx_vpu_dma_buffer_deallocate(jpeg_decoder->bitstream_buffer);
IMX_VPU_FREE(jpeg_decoder, sizeof(ImxVpuJPEGDecoder));
return IMX_VPU_DEC_RETURN_CODE_OK;
}
ImxVpuDecReturnCodes imx_vpu_dec_decode_frame(ImxVpuDecoder *decoder, ImxVpuEncodedFrame const *encoded_frame, unsigned int *output_code)
{
VpuDecRetCode ret;
VpuBufferNode node;
int buf_ret_code;
node.pVirAddr = encoded_frame->virtual_address;
node.pPhyAddr = 0; /* encoded data is always read from a regular memory block, not a DMA buffer */
node.nSize = encoded_frame->data_size;
node.sCodecData.pData = encoded_frame->codec_data;
node.sCodecData.nSize = encoded_frame->codec_data_size;
decoder->pending_user_data = encoded_frame->user_data;
ret = VPU_DecDecodeBuf(decoder->handle, &node, &buf_ret_code);
IMX_VPU_LOG("VPU_DecDecodeBuf buf ret code: 0x%x", buf_ret_code);
*output_code = dec_convert_outcode(buf_ret_code);
if (ret != VPU_DEC_RET_SUCCESS)
{
IMX_VPU_ERROR("decoding frame failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
return dec_convert_retcode(ret);
}
if (decoder->recalculate_num_avail_framebuffers)
{
decoder->num_available_framebuffers = decoder->num_framebuffers - decoder->num_framebuffers_in_use;
IMX_VPU_LOG("recalculated number of available framebuffers to %d", decoder->num_available_framebuffers);
decoder->recalculate_num_avail_framebuffers = FALSE;
}
if (buf_ret_code & VPU_DEC_INIT_OK)
{
decoder->delay_pending_user_data = TRUE;
decoder->last_pending_user_data = decoder->pending_user_data;
}
if (buf_ret_code & VPU_DEC_FLUSH)
{
IMX_VPU_INFO("VPU requested a decoder flush");
ret = VPU_DecFlushAll(decoder->handle);
if (ret == VPU_DEC_RET_FAILURE_TIMEOUT)
{
IMX_VPU_WARNING("timeout detected, resetting decoder");
ret = VPU_DecReset(decoder->handle);
if (ret != VPU_DEC_RET_SUCCESS)
{
ImxVpuDecReturnCodes imxret = dec_convert_retcode(ret);
IMX_VPU_ERROR("resetting decoder failed: %s", imx_vpu_dec_error_string(imxret));
return imxret;
}
else
*output_code |= IMX_VPU_DEC_OUTPUT_CODE_INTERNAL_RESET;
}
else if (ret != VPU_DEC_RET_SUCCESS)
{
ImxVpuDecReturnCodes imxret = dec_convert_retcode(ret);
IMX_VPU_ERROR("flushing decoder failed: %s", imx_vpu_dec_error_string(imxret));
return imxret;
}
else
IMX_VPU_INFO("flushed decoder");
}
if (buf_ret_code & VPU_DEC_RESOLUTION_CHANGED)
{
IMX_VPU_INFO("resolution changed - resetting internal states");
*output_code |= IMX_VPU_DEC_OUTPUT_CODE_INITIAL_INFO_AVAILABLE;
decoder->delay_pending_user_data = TRUE;
decoder->recalculate_num_avail_framebuffers = FALSE;
decoder->num_user_data = 0;
if (decoder->user_data_for_frames != NULL)
IMX_VPU_FREE(decoder->user_data_for_frames, sizeof(void*) * decoder->num_framebuffers);
if (decoder->wrapper_framebuffers != NULL)
IMX_VPU_FREE(decoder->wrapper_framebuffers, sizeof(VpuFrameBuffer*) * decoder->num_framebuffers);
decoder->user_data_for_frames = NULL;
decoder->wrapper_framebuffers = NULL;
}
if (buf_ret_code & VPU_DEC_NO_ENOUGH_INBUF)
{
/* Not dropping frame here on purpose; the next input frame may
* complete the input */
}
{
void *user_data = decoder->delay_pending_user_data ? decoder->last_pending_user_data : decoder->pending_user_data;
/* The first time this location is reached, VPU_DEC_INIT_OK will be set in the output_code.
* This implies that the framebuffers have not been allocated and registered yet,
* so no user data can be stored yet.
* With codec formats that produce consumption info, this is not a problem, because
* VPU_DEC_ONE_FRM_CONSUMED will be returned only when framebuffers are present.
* But with other formats, an explicit decoder->framebuffers != NULL check is necessary
* (see below). The user_data pointer does not get lost; it is stored in last_pending_user_data. */
if ((buf_ret_code & VPU_DEC_ONE_FRM_CONSUMED) && !(buf_ret_code & VPU_DEC_OUTPUT_DROPPED))
{
int fb_index;
VpuDecFrameLengthInfo consumed_frame_info;
ret = VPU_DecGetConsumedFrameInfo(decoder->handle, &consumed_frame_info);
if (ret != VPU_DEC_RET_SUCCESS)
{
ImxVpuDecReturnCodes imxret = dec_convert_retcode(ret);
IMX_VPU_ERROR("getting consumed frame info failed: %s", imx_vpu_dec_error_string(imxret));
return imxret;
}
fb_index = dec_get_wrapper_framebuffer_index(decoder, consumed_frame_info.pFrame);
if (consumed_frame_info.pFrame != NULL)
{
if ((fb_index >= 0) && (fb_index < (int)(decoder->num_framebuffers)))
{
IMX_VPU_LOG("framebuffer index %d for framebuffer %p user data %p", fb_index, (void *)(consumed_frame_info.pFrame), user_data);
decoder->user_data_for_frames[fb_index] = user_data;
}
else
IMX_VPU_ERROR("framebuffer index %d for framebuffer %p user data %p out of bounds", fb_index, (void *)(consumed_frame_info.pFrame), user_data);
}
else
IMX_VPU_WARNING("consumed frame info contains a NULL frame");
}
else if (!(decoder->consumption_info_available) && (decoder->framebuffers != NULL))
{
if (decoder->num_user_data < (int)(decoder->num_framebuffers))
{
decoder->user_data_for_frames[decoder->num_user_data] = user_data;
decoder->num_user_data++;
IMX_VPU_LOG("user data %p stored as newest", user_data);
IMX_VPU_TRACE("incremented number of userdata pointers to %d", decoder->num_user_data);
}
else
IMX_VPU_WARNING("too many user data pointers in memory - cannot store current one");
}
decoder->last_pending_user_data = decoder->pending_user_data;
decoder->pending_user_data = NULL;
}
if ((buf_ret_code & VPU_DEC_ONE_FRM_CONSUMED) && !(buf_ret_code & VPU_DEC_OUTPUT_DROPPED))
{
decoder->num_available_framebuffers--;
decoder->num_times_counter_decremented++;
IMX_VPU_LOG("decremented number of available framebuffers to %d (with consumed frame info); number of times decremented is now %d", decoder->num_available_framebuffers, decoder->num_times_counter_decremented);
}
if (buf_ret_code & VPU_DEC_OUTPUT_NODIS)
{
if ((encoded_frame->virtual_address != NULL) && (decoder->codec_format == IMX_VPU_CODEC_FORMAT_VP8))
*output_code |= IMX_VPU_DEC_OUTPUT_CODE_DECODE_ONLY;
}
/* VPU_DEC_NO_ENOUGH_BUF handled by caller - should be treated as an error */
if ((buf_ret_code & VPU_DEC_OUTPUT_DIS) && !(decoder->consumption_info_available))
{
decoder->num_available_framebuffers--;
decoder->num_times_counter_decremented++;
IMX_VPU_LOG("decremented number of available framebuffers to %d (no consumed frame info); number of times decremented is now %d", decoder->num_available_framebuffers, decoder->num_times_counter_decremented);
}
else if (buf_ret_code & VPU_DEC_OUTPUT_MOSAIC_DIS)
{
IMX_VPU_TRACE("dropping mosaic frame");
/* mosaic frames do not seem to be useful for anything, so they are just dropped here */
ImxVpuDecReturnCodes imxret;
ImxVpuDecodedFrame decoded_frame;
if ((imxret = imx_vpu_dec_get_decoded_frame(decoder, &decoded_frame)) != IMX_VPU_DEC_RETURN_CODE_OK)
{
IMX_VPU_ERROR("error getting output mosaic frame: %s", imx_vpu_dec_error_string(imxret));
return imxret;
}
if ((imxret = imx_vpu_dec_mark_framebuffer_as_displayed(decoder, decoded_frame.framebuffer)) != IMX_VPU_DEC_RETURN_CODE_OK)
{
IMX_VPU_ERROR("error marking mosaic frame as displayed: %s", imx_vpu_dec_error_string(imxret));
return imxret;
}
decoder->dropped_frame_user_data = decoded_frame.user_data;
*output_code |= IMX_VPU_DEC_OUTPUT_CODE_DROPPED;
}
else if (buf_ret_code & VPU_DEC_OUTPUT_DROPPED)
{
// TODO make this work for formats with consumption info
if (decoder->num_user_data > 0)
{
decoder->dropped_frame_user_data = decoder->user_data_for_frames[0];
decoder->user_data_for_frames[0] = NULL;
memmove(decoder->user_data_for_frames, decoder->user_data_for_frames + 1, sizeof(void*) * (decoder->num_user_data - 1));
decoder->num_user_data--;
}
else
decoder->dropped_frame_user_data = NULL;
}
/* In case the VPU didn't use the input and no consumed frame info is available,
* drop the input frame to make sure timestamps are okay
* (If consumed frame info is present it is still possible it might be used for input-output frame
* associations; unlikely to occur thought) */
if ((encoded_frame->virtual_address != NULL) && !(buf_ret_code & (VPU_DEC_ONE_FRM_CONSUMED | VPU_DEC_INPUT_USED | VPU_DEC_RESOLUTION_CHANGED)))
{
decoder->dropped_frame_user_data = encoded_frame->user_data;
*output_code |= IMX_VPU_DEC_OUTPUT_CODE_DROPPED;
}
return IMX_VPU_DEC_RETURN_CODE_OK;
}
ImxVpuDecReturnCodes imx_vpu_dec_open(ImxVpuDecoder **decoder, ImxVpuDecOpenParams const *open_params, void *bitstream_buffer_virtual_address, imx_vpu_phys_addr_t bitstream_buffer_physical_addres)
{
int config_param;
VpuDecRetCode ret;
VpuMemInfo mem_info;
VpuDecOpenParam open_param;
*decoder = IMX_VPU_ALLOC(sizeof(ImxVpuDecoder));
if ((*decoder) == NULL)
{
IMX_VPU_ERROR("allocating memory for decoder object failed");
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
memset(*decoder, 0, sizeof(ImxVpuDecoder));
{
int i;
VPU_DecQueryMem(&mem_info);
IMX_VPU_INFO("about to allocate %d memory sub blocks", mem_info.nSubBlockNum);
for (i = 0; i < mem_info.nSubBlockNum; ++i)
{
char const *type_str = "<unknown>";
VpuMemSubBlockInfo *sub_block = &(mem_info.MemSubBlock[i]);
switch (sub_block->MemType)
{
case VPU_MEM_VIRT:
type_str = "virtual";
(*decoder)->virt_mem_sub_block_size = sub_block->nSize + sub_block->nAlignment;
(*decoder)->virt_mem_sub_block = IMX_VPU_ALLOC((*decoder)->virt_mem_sub_block_size);
if ((*decoder)->virt_mem_sub_block == NULL)
{
IMX_VPU_ERROR("allocating memory for sub block failed");
return IMX_VPU_DEC_RETURN_CODE_ERROR;
}
sub_block->pVirtAddr = (unsigned char *)IMX_VPU_ALIGN_VAL_TO((*decoder)->virt_mem_sub_block, sub_block->nAlignment);
sub_block->pPhyAddr = 0;
break;
case VPU_MEM_PHY:
type_str = "physical";
sub_block->pVirtAddr = (unsigned char *)(bitstream_buffer_virtual_address);
sub_block->pPhyAddr = (unsigned char *)(bitstream_buffer_physical_addres);
break;
default:
break;
}
IMX_VPU_INFO("allocated memory sub block #%d: type: %s size: %d alignment: %d virtual address: %p physical address: %p", i, type_str, sub_block->nSize, sub_block->nAlignment, sub_block->pVirtAddr, sub_block->pPhyAddr);
}
}
dec_convert_to_wrapper_open_param(open_params, &open_param);
IMX_VPU_TRACE("opening decoder");
switch (open_params->codec_format)
{
case IMX_VPU_CODEC_FORMAT_H264:
case IMX_VPU_CODEC_FORMAT_H264_MVC:
case IMX_VPU_CODEC_FORMAT_MPEG2:
case IMX_VPU_CODEC_FORMAT_MPEG4:
(*decoder)->consumption_info_available = TRUE;
(*decoder)->flush_vpu_upon_reset = TRUE;
break;
case IMX_VPU_CODEC_FORMAT_H263:
case IMX_VPU_CODEC_FORMAT_WMV3:
case IMX_VPU_CODEC_FORMAT_WVC1:
(*decoder)->consumption_info_available = FALSE;
(*decoder)->flush_vpu_upon_reset = FALSE;
break;
case IMX_VPU_CODEC_FORMAT_MJPEG:
case IMX_VPU_CODEC_FORMAT_VP8:
(*decoder)->consumption_info_available = FALSE;
(*decoder)->flush_vpu_upon_reset = TRUE;
break;
default:
break;
}
ret = VPU_DecOpen(&((*decoder)->handle), &open_param, &mem_info);
if (ret != VPU_DEC_RET_SUCCESS)
{
IMX_VPU_ERROR("opening decoder failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
goto cleanup;
}
IMX_VPU_TRACE("setting configuration");
config_param = VPU_DEC_SKIPNONE;
ret = VPU_DecConfig((*decoder)->handle, VPU_DEC_CONF_SKIPMODE, &config_param);
if (ret != VPU_DEC_RET_SUCCESS)
{
IMX_VPU_ERROR("setting skipmode to NONE failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
goto cleanup;
}
config_param = 0;
ret = VPU_DecConfig((*decoder)->handle, VPU_DEC_CONF_BUFDELAY, &config_param);
if (ret != VPU_DEC_RET_SUCCESS)
{
IMX_VPU_ERROR("setting bufdelay to 0 failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
goto cleanup;
}
config_param = VPU_DEC_IN_NORMAL;
ret = VPU_DecConfig((*decoder)->handle, VPU_DEC_CONF_INPUTTYPE, &config_param);
if (ret != VPU_DEC_RET_SUCCESS)
{
IMX_VPU_ERROR("setting input type to \"normal\" failed: %s", imx_vpu_dec_error_string(dec_convert_retcode(ret)));
goto cleanup;
}
(*decoder)->codec_format = open_params->codec_format;
finish:
if (ret == VPU_DEC_RET_SUCCESS)
IMX_VPU_TRACE("successfully opened decoder");
return dec_convert_retcode(ret);
cleanup:
if ((*decoder)->virt_mem_sub_block != NULL)
IMX_VPU_FREE((*decoder)->virt_mem_sub_block, (*decoder)->virt_mem_sub_block_size);
IMX_VPU_FREE(*decoder, sizeof(ImxVpuDecoder));
*decoder = NULL;
goto finish;
}
