u32 ddl_encode_start(u32 *ddl_handle, void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
struct ddl_encoder_data *encoder;
void *ptr;
u32 status = VCD_S_SUCCESS;
DDL_MSG_HIGH("ddl_encode_start");
#ifdef DDL_PROFILE
if (first_time < 2) {
ddl_reset_time_variables(1);
first_time++;
}
ddl_get_core_start_time(1);
#endif
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_start:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_start:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || ddl->decoding) {
DDL_MSG_ERROR("ddl_enc_start:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN)) {
DDL_MSG_ERROR("ddl_enc_start:Not_opened");
return VCD_ERR_ILLEGAL_OP;
}
if (!ddl_encoder_ready_to_start(ddl)) {
DDL_MSG_ERROR("ddl_enc_start:Err_param_settings");
return VCD_ERR_ILLEGAL_OP;
}
encoder = &ddl->codec_data.encoder;
status = ddl_allocate_enc_hw_buffers(ddl);
if (status)
return status;
#ifdef DDL_BUF_LOG
ddl_list_buffers(ddl);
#endif
ptr = ddl_pmem_alloc(&encoder->seq_header,
DDL_ENC_SEQHEADER_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES);
if (!ptr) {
ddl_free_enc_hw_buffers(ddl);
DDL_MSG_ERROR("ddl_enc_start:Seq_hdr_alloc_failed");
return VCD_ERR_ALLOC_FAIL;
}
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
ddl_vidc_channel_set(ddl);
return status;
}
u32 ddl_encode_frame(u32 *ddl_handle,
struct ddl_frame_data_tag *input_frame,
struct ddl_frame_data_tag *output_bit, void *client_data)
{
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
u32 vcd_status = VCD_S_SUCCESS;
DDL_MSG_HIGH("ddl_encode_frame");
#ifdef DDL_PROFILE
ddl_get_core_start_time(1);
#endif
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_frame:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_enc_frame:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || ddl->decoding) {
DDL_MSG_ERROR("ddl_enc_frame:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!input_frame || !input_frame->vcd_frm.physical ||
!input_frame->vcd_frm.data_len) {
DDL_MSG_ERROR("ddl_enc_frame:Bad_input_params");
return VCD_ERR_ILLEGAL_PARM;
}
if ((((u32) input_frame->vcd_frm.physical +
input_frame->vcd_frm.offset) &
(DDL_STREAMBUF_ALIGN_GUARD_BYTES))) {
DDL_MSG_ERROR("ddl_enc_frame:Un_aligned_yuv_start_address");
return VCD_ERR_ILLEGAL_PARM;
}
if (!output_bit || !output_bit->vcd_frm.physical ||
!output_bit->vcd_frm.alloc_len) {
DDL_MSG_ERROR("ddl_enc_frame:Bad_output_params");
return VCD_ERR_ILLEGAL_PARM;
}
if ((ddl->codec_data.encoder.output_buf_req.sz +
output_bit->vcd_frm.offset) >
output_bit->vcd_frm.alloc_len)
DDL_MSG_ERROR("ddl_enc_frame:offset_large,"
"Exceeds_min_buf_size");
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME)) {
DDL_MSG_ERROR("ddl_enc_frame:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
ddl->input_frame = *input_frame;
ddl->output_frame = *output_bit;
if (ddl->codec_data.encoder.i_period.b_frames > 0) {
if (!ddl->b_count) {
ddl->first_output_frame = *output_bit;
ddl->b_count++;
} else if (ddl->codec_data.encoder.i_period.b_frames >=
ddl->b_count) {
ddl->extra_output_frame[ddl->b_count-1] =
*output_bit;
ddl->output_frame = ddl->first_output_frame;
ddl->b_count++;
}
}
ddl_insert_input_frame_to_pool(ddl, input_frame);
if (!vcd_status)
ddl_vidc_encode_frame_run(ddl);
else
DDL_MSG_ERROR("insert to frame pool failed %u", vcd_status);
return vcd_status;
}
u32 ddl_decode_frame(u32 *ddl_handle,
struct ddl_frame_data_tag *input_bits, void *client_data)
{
u32 vcd_status = VCD_S_SUCCESS;
struct ddl_client_context *ddl =
(struct ddl_client_context *) ddl_handle;
struct ddl_context *ddl_context;
struct ddl_decoder_data *decoder;
DDL_MSG_HIGH("ddl_decode_frame");
#ifdef DDL_PROFILE
ddl_get_core_start_time(0);
#endif
ddl_context = ddl_get_context();
if (!DDL_IS_INITIALIZED(ddl_context)) {
DDL_MSG_ERROR("ddl_dec_frame:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(ddl_context)) {
DDL_MSG_ERROR("ddl_dec_frame:Ddl_busy");
return VCD_ERR_BUSY;
}
if (!ddl || !ddl->decoding) {
DDL_MSG_ERROR("ddl_dec_frame:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (!input_bits || ((!input_bits->vcd_frm.physical ||
!input_bits->vcd_frm.data_len) &&
(!(VCD_FRAME_FLAG_EOS & input_bits->vcd_frm.flags)))) {
DDL_MSG_ERROR("ddl_dec_frame:Bad_input_param");
return VCD_ERR_ILLEGAL_PARM;
}
if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODEC) &&
!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPB)) {
DDL_MSG_ERROR("Dec_frame:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
decoder = &(ddl->codec_data.decoder);
if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODEC) &&
!ddl->codec_data.decoder.dp_buf.no_of_dec_pic_buf) {
DDL_MSG_ERROR("ddl_dec_frame:Dpbs_requied");
return VCD_ERR_ILLEGAL_OP;
}
if (!ddl_take_command_channel(ddl_context, ddl, client_data))
return VCD_ERR_BUSY;
ddl->input_frame = *input_bits;
if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_FRAME))
ddl_vidc_decode_frame_run(ddl);
else {
if (!ddl->codec_data.decoder.dp_buf.no_of_dec_pic_buf) {
DDL_MSG_ERROR("ddl_dec_frame:Dpbs_requied");
vcd_status = VCD_ERR_ILLEGAL_OP;
} else if (DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_DPB)) {
vcd_status = ddl_vidc_decode_set_buffers(ddl);
if (vcd_status)
ddl_release_command_channel(ddl_context,
ddl->command_channel);
} else if (DDLCLIENT_STATE_IS(ddl,
DDL_CLIENT_WAIT_FOR_INITCODEC)) {
if (decoder->codec.codec == VCD_CODEC_DIVX_3) {
if ((!decoder->client_frame_size.width) ||
(!decoder->client_frame_size.height))
return VCD_ERR_ILLEGAL_OP;
}
ddl->codec_data.decoder.decode_config.sequence_header =
ddl->input_frame.vcd_frm.physical;
ddl->codec_data.decoder.decode_config.sequence_header_len =
ddl->input_frame.vcd_frm.data_len;
ddl_vidc_decode_init_codec(ddl);
} else {
DDL_MSG_ERROR("Dec_frame:Wrong_state");
vcd_status = VCD_ERR_ILLEGAL_OP;
}
if (vcd_status)
DDL_IDLE(ddl_context);
}
return vcd_status;
}
u32 ddl_encode_frame(u32 *ddl_handle,
struct ddl_frame_data_type_tag *p_input_frame,
struct ddl_frame_data_type_tag *p_output_bit, void *p_client_data)
{
struct ddl_client_context_type *p_ddl =
(struct ddl_client_context_type *)ddl_handle;
struct ddl_context_type *p_ddl_context = ddl_get_context();
#ifdef CORE_TIMING_INFO
ddl_get_core_start_time(1);
#endif
if (!DDL_IS_INITIALIZED(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_enc_frame:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_enc_frame:Ddl_busy");
return VCD_ERR_BUSY;
}
if (NULL == p_ddl || TRUE == p_ddl->b_decoding) {
VIDC_LOGERR_STRING("ddl_enc_frame:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (NULL == p_input_frame ||
NULL == p_input_frame->vcd_frm.p_physical ||
p_ddl->codec_data.encoder.input_buf_req.n_size !=
p_input_frame->vcd_frm.n_data_len) {
VIDC_LOGERR_STRING("ddl_enc_frame:Bad_input_params");
return VCD_ERR_ILLEGAL_PARM;
}
if (0 != (((u32) p_input_frame->vcd_frm.p_physical +
p_input_frame->vcd_frm.n_offset) &
(DDL_STREAMBUF_ALIGN_GUARD_BYTES)
)
) {
VIDC_LOGERR_STRING
("ddl_enc_frame:Un_aligned_yuv_start_address");
return VCD_ERR_ILLEGAL_PARM;
}
if (NULL == p_output_bit ||
NULL == p_output_bit->vcd_frm.p_physical ||
0 == p_output_bit->vcd_frm.n_alloc_len) {
VIDC_LOGERR_STRING("ddl_enc_frame:Bad_output_params");
return VCD_ERR_ILLEGAL_PARM;
}
if ((p_ddl->codec_data.encoder.output_buf_req.n_size +
p_output_bit->vcd_frm.n_offset) >
p_output_bit->vcd_frm.n_alloc_len) {
VIDC_LOGERR_STRING
("ddl_enc_frame:n_offset_large, Exceeds_min_buf_size");
}
if (!DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME)) {
VIDC_LOGERR_STRING("ddl_enc_frame:Wrong_state");
return VCD_ERR_ILLEGAL_OP;
}
DDL_BUSY(p_ddl_context);
p_ddl_context->p_current_ddl = p_ddl;
p_ddl_context->p_client_data = p_client_data;
p_ddl->input_frame = *p_input_frame;
p_ddl->output_frame = *p_output_bit;
ddl_encode_frame_run(p_ddl);
return VCD_S_SUCCESS;
}
u32 ddl_decode_frame(u32 *ddl_handle,
struct ddl_frame_data_type_tag *p_input_bits, void *p_client_data)
{
u32 vcd_status = VCD_S_SUCCESS;
struct ddl_client_context_type *p_ddl =
(struct ddl_client_context_type *)ddl_handle;
struct ddl_context_type *p_ddl_context = ddl_get_context();
#ifdef CORE_TIMING_INFO
ddl_get_core_start_time(0);
#endif
if (!DDL_IS_INITIALIZED(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_frame:Not_inited");
return VCD_ERR_ILLEGAL_OP;
}
if (DDL_IS_BUSY(p_ddl_context)) {
VIDC_LOGERR_STRING("ddl_dec_frame:Ddl_busy");
return VCD_ERR_BUSY;
}
if (NULL == p_ddl || FALSE == p_ddl->b_decoding) {
VIDC_LOGERR_STRING("ddl_dec_frame:Bad_handle");
return VCD_ERR_BAD_HANDLE;
}
if (NULL == p_input_bits ||
((0 == p_input_bits->vcd_frm.p_physical ||
0 == p_input_bits->vcd_frm.n_data_len) &&
(0 == (VCD_FRAME_FLAG_EOS & p_input_bits->vcd_frm.n_flags))
)
) {
VIDC_LOGERR_STRING("ddl_dec_frame:Bad_input_param");
return VCD_ERR_ILLEGAL_PARM;
}
DDL_BUSY(p_ddl_context);
p_ddl_context->p_current_ddl = p_ddl;
p_ddl_context->p_client_data = p_client_data;
p_ddl->input_frame = *p_input_bits;
if (DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_FRAME)) {
ddl_decode_frame_run(p_ddl);
} else {
if (0 == p_ddl->codec_data.decoder.dp_buf.n_no_of_dec_pic_buf) {
VIDC_LOGERR_STRING("ddl_dec_frame:Dpbs_requied");
vcd_status = VCD_ERR_ILLEGAL_OP;
} else if (DDLCLIENT_STATE_IS(p_ddl, DDL_CLIENT_WAIT_FOR_DPB)) {
vcd_status = ddl_decode_set_buffers(p_ddl);
} else if (DDLCLIENT_STATE_IS
(p_ddl, DDL_CLIENT_WAIT_FOR_INITCODEC)) {
p_ddl->codec_data.decoder.decode_config.
p_sequence_header =
p_ddl->input_frame.vcd_frm.p_physical;
p_ddl->codec_data.decoder.decode_config.
n_sequence_header_len =
p_ddl->input_frame.vcd_frm.n_data_len;
ddl_decode_init_codec(p_ddl);
} else {
VIDC_LOGERR_STRING("Dec_frame:Wrong_state");
vcd_status = VCD_ERR_ILLEGAL_OP;
}
if (VCD_S_SUCCESS != vcd_status)
DDL_IDLE(p_ddl_context);
}
return vcd_status;
}
