u32 ddl_decode_start(u32 *ddl_handle, struct vcd_sequence_hdr *header, void *client_data) { struct ddl_client_context *ddl = (struct ddl_client_context *) ddl_handle; struct ddl_context *ddl_context; struct ddl_decoder_data *decoder; u32 status = VCD_S_SUCCESS; DDL_MSG_HIGH("ddl_decode_start"); if (vidc_msg_timing) { ddl_reset_core_time_variables(DEC_OP_TIME); ddl_reset_core_time_variables(DEC_IP_TIME); } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dec_start:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (DDL_IS_BUSY(ddl_context)) { DDL_MSG_ERROR("ddl_dec_start:Ddl_busy"); return VCD_ERR_BUSY; } if (!ddl || !ddl->decoding) { DDL_MSG_ERROR("ddl_dec_start:Bad_handle"); return VCD_ERR_BAD_HANDLE; } if (!DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_OPEN)) { DDL_MSG_ERROR("ddl_dec_start:Not_in_opened_state"); return VCD_ERR_ILLEGAL_OP; } if ((header) && ((!header->sequence_header_len) || (!header->sequence_header))) { DDL_MSG_ERROR("ddl_dec_start:Bad_param_seq_header"); return VCD_ERR_ILLEGAL_PARM; } if (!ddl_decoder_ready_to_start(ddl, header)) { DDL_MSG_ERROR("ddl_dec_start:Err_param_settings"); return VCD_ERR_ILLEGAL_OP; } decoder = &ddl->codec_data.decoder; status = ddl_allocate_dec_hw_buffers(ddl); if (status) return status; #ifdef DDL_BUF_LOG ddl_list_buffers(ddl); #endif if (!ddl_take_command_channel(ddl_context, ddl, client_data)) return VCD_ERR_BUSY; if (header) { decoder->header_in_start = true; decoder->decode_config = *header; } else { decoder->header_in_start = false; decoder->decode_config.sequence_header_len = 0; } ddl_vidc_channel_set(ddl); return status; }
u32 ddl_close(u32 **ddl_handle) { struct ddl_context *ddl_context; struct ddl_client_context **pp_ddl = (struct ddl_client_context **)ddl_handle; DDL_MSG_HIGH("ddl_close"); if (!pp_ddl || !*pp_ddl) { DDL_MSG_ERROR("ddl_close:Bad_handle"); return VCD_ERR_BAD_HANDLE; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_close:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (!DDLCLIENT_STATE_IS(*pp_ddl, DDL_CLIENT_OPEN)) { DDL_MSG_ERROR("ddl_close:Not_in_open_state"); return VCD_ERR_ILLEGAL_OP; } ddl_pmem_free(&(*pp_ddl)->shared_mem[0]); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) ddl_pmem_free(&(*pp_ddl)->shared_mem[1]); DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_INVALID", ddl_get_state_string((*pp_ddl)->client_state)); (*pp_ddl)->client_state = DDL_CLIENT_INVALID; ddl_codec_type_transact(*pp_ddl, true, (enum vcd_codec)0); ddl_client_transact(DDL_FREE_CLIENT, pp_ddl); return VCD_S_SUCCESS; }
u32 ddl_encode_end(u32 *ddl_handle, void *client_data) { struct ddl_client_context *ddl = (struct ddl_client_context *) ddl_handle; struct ddl_context *ddl_context; DDL_MSG_HIGH("ddl_encode_end"); ddl_reset_core_time_variables(ENC_OP_TIME); ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_enc_end:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (DDL_IS_BUSY(ddl_context)) { DDL_MSG_ERROR("ddl_enc_end:Ddl_busy"); return VCD_ERR_BUSY; } if (!ddl || ddl->decoding) { DDL_MSG_ERROR("ddl_enc_end:Bad_handle"); return VCD_ERR_BAD_HANDLE; } 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_FAVIDC_ERROR)) { DDL_MSG_ERROR("ddl_enc_end:Wrong_state"); return VCD_ERR_ILLEGAL_OP; } if (!ddl_take_command_channel(ddl_context, ddl, client_data)) return VCD_ERR_BUSY; ddl_vidc_channel_end(ddl); return VCD_S_SUCCESS; }
u32 ddl_reset_hw(u32 mode) { struct ddl_context *ddl_context; struct ddl_client_context *ddl; u32 i; DDL_MSG_HIGH("ddl_reset_hw"); DDL_MSG_LOW("ddl_reset_hw:called"); ddl_context = ddl_get_context(); ddl_context->cmd_state = DDL_CMD_INVALID; DDL_BUSY(ddl_context); if (ddl_context->core_virtual_base_addr) { vidc_1080p_do_sw_reset(VIDC_1080P_RESET_IN_SEQ_FIRST_STAGE); msleep(DDL_SW_RESET_SLEEP); vidc_1080p_do_sw_reset(VIDC_1080P_RESET_IN_SEQ_SECOND_STAGE); msleep(DDL_SW_RESET_SLEEP); ddl_context->core_virtual_base_addr = NULL; } ddl_context->device_state = DDL_DEVICE_NOTINIT; for (i = 0; i < VCD_MAX_NO_CLIENT; i++) { ddl = ddl_context->ddl_clients[i]; ddl_context->ddl_clients[i] = NULL; if (ddl) { ddl_release_client_internal_buffers(ddl); ddl_client_transact(DDL_FREE_CLIENT, &ddl); } } ddl_release_context_buffers(ddl_context); memset(ddl_context, 0, sizeof(struct ddl_context)); return true; }
u32 ddl_open(u32 **ddl_handle, u32 decoding) { struct ddl_context *ddl_context; struct ddl_client_context *ddl; void *ptr; u32 status; DDL_MSG_HIGH("ddl_open"); if (!ddl_handle) { DDL_MSG_ERROR("ddl_open:Bad_handle"); return VCD_ERR_BAD_HANDLE; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_open:Not_inited"); return VCD_ERR_ILLEGAL_OP; } status = ddl_client_transact(DDL_GET_CLIENT, &ddl); if (status) { DDL_MSG_ERROR("ddl_open:Client_trasac_failed"); return status; } ptr = ddl_pmem_alloc(&ddl->shared_mem[0], DDL_FW_AUX_HOST_CMD_SPACE_SIZE, sizeof(u32)); if (!ptr) status = VCD_ERR_ALLOC_FAIL; if (!status && ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) { ptr = ddl_pmem_alloc(&ddl->shared_mem[1], DDL_FW_AUX_HOST_CMD_SPACE_SIZE, sizeof(u32)); if (!ptr) { ddl_pmem_free(&ddl->shared_mem[0]); status = VCD_ERR_ALLOC_FAIL; } } if (!status) { memset(ddl->shared_mem[0].align_virtual_addr, 0, DDL_FW_AUX_HOST_CMD_SPACE_SIZE); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) { memset(ddl->shared_mem[1].align_virtual_addr, 0, DDL_FW_AUX_HOST_CMD_SPACE_SIZE); } DDL_MSG_LOW("ddl_state_transition: %s ~~> DDL_CLIENT_OPEN", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_OPEN; ddl->codec_data.hdr.decoding = decoding; ddl->decoding = decoding; ddl_set_default_meta_data_hdr(ddl); ddl_set_initial_default_values(ddl); *ddl_handle = (u32 *) ddl; } else { ddl_pmem_free(&ddl->shared_mem[0]); if (ddl_context->frame_channel_depth == VCD_DUAL_FRAME_COMMAND_CHANNEL) ddl_pmem_free(&ddl->shared_mem[1]); ddl_client_transact(DDL_FREE_CLIENT, &ddl); } return status; }
u32 ddl_device_release(void *client_data) { struct ddl_context *ddl_context; DDL_MSG_HIGH("ddl_device_release"); ddl_context = ddl_get_context(); if (!DDL_IS_IDLE(ddl_context)) { DDL_MSG_ERROR("ddl_dev_rel:Ddl_busy"); return VCD_ERR_BUSY; } if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dev_rel:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (!ddl_client_transact(DDL_ACTIVE_CLIENT, NULL)) { DDL_MSG_ERROR("ddl_dev_rel:Client_present_err"); return VCD_ERR_CLIENT_PRESENT; } DDL_BUSY(ddl_context); ddl_context->device_state = DDL_DEVICE_NOTINIT; ddl_context->client_data = client_data; ddl_context->cmd_state = DDL_CMD_INVALID; ddl_vidc_core_term(ddl_context); DDL_MSG_LOW("FW_ENDDONE"); ddl_context->core_virtual_base_addr = NULL; ddl_release_context_buffers(ddl_context); ddl_context->video_ion_client = NULL; DDL_IDLE(ddl_context); return VCD_S_SUCCESS; }
static u32 ddl_get_decoded_frame(struct vcd_frame_data *frame, enum vidc_1080p_decode_frame frame_type) { u32 status = true; switch (frame_type) { case VIDC_1080P_DECODE_FRAMETYPE_I: frame->flags |= VCD_FRAME_FLAG_SYNCFRAME; frame->frame = VCD_FRAME_I; break; case VIDC_1080P_DECODE_FRAMETYPE_P: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_DECODE_FRAMETYPE_B: frame->frame = VCD_FRAME_B; break; case VIDC_1080P_DECODE_FRAMETYPE_NOT_CODED: frame->frame = VCD_FRAME_NOTCODED; frame->data_len = 0; DDL_MSG_HIGH("DDL_INFO:Decoder:NotCodedFrame>"); break; case VIDC_1080P_DECODE_FRAMETYPE_OTHERS: frame->frame = VCD_FRAME_YUV; break; case VIDC_1080P_DECODE_FRAMETYPE_32BIT: default: DDL_MSG_ERROR("UNKNOWN-FRAMETYPE"); status = false; break; } return status; }
u32 ddl_set_property(u32 *ddl_handle, struct vcd_property_hdr *property_hdr, void *property_value) { struct ddl_context *ddl_context; struct ddl_client_context *ddl = (struct ddl_client_context *) ddl_handle; u32 vcd_status; DDL_MSG_HIGH("ddl_set_property"); if (!property_hdr || !property_value) { DDL_MSG_ERROR("ddl_set_prop:Bad_argument"); return VCD_ERR_ILLEGAL_PARM; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_set_prop:Not_inited"); return VCD_ERR_ILLEGAL_OP; } if (!ddl) { DDL_MSG_ERROR("ddl_set_prop:Bad_handle"); return VCD_ERR_BAD_HANDLE; } if (ddl->decoding) vcd_status = ddl_set_dec_property(ddl, property_hdr, property_value); else vcd_status = ddl_set_enc_property(ddl, property_hdr, property_value); if (vcd_status) DDL_MSG_ERROR("ddl_set_prop:FAILED"); return vcd_status; }
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; }
static u32 ddl_frame_run_callback(struct ddl_context *ddl_context) { struct ddl_client_context *ddl; u32 channel_inst_id; u32 return_status = true; vidc_1080p_get_returned_channel_inst_id(&channel_inst_id); vidc_1080p_clear_returned_channel_inst_id(); ddl = ddl_get_current_ddl_client_for_channel_id(ddl_context, ddl_context->response_cmd_ch_id); if (ddl) { if (ddl_context->pix_cache_enable) { struct vidc_1080P_pix_cache_statistics pixel_cache_stats; vidc_pix_cache_get_statistics(&pixel_cache_stats); DDL_MSG_HIGH(" pixel cache hits = %d," "miss = %d", pixel_cache_stats.access_hit, pixel_cache_stats.access_miss); DDL_MSG_HIGH(" pixel cache core reqs = %d," "axi reqs = %d", pixel_cache_stats.core_req, pixel_cache_stats.axi_req); DDL_MSG_HIGH(" pixel cache core bus stats = %d," "axi bus stats = %d", pixel_cache_stats.core_bus, pixel_cache_stats.axi_bus); } if (ddl->cmd_state == DDL_CMD_DECODE_FRAME) return_status = ddl_decoder_frame_run_callback(ddl); else if (ddl->cmd_state == DDL_CMD_ENCODE_FRAME) ddl_encoder_frame_run_callback(ddl); else if (ddl->cmd_state == DDL_CMD_EOS) return_status = ddl_eos_frame_done_callback(ddl); else { DDL_MSG_ERROR("UNKWN_FRAME_DONE"); return_status = false; } } else return_status = false; return return_status; }
u32 ddl_get_property(u32 *ddl_handle, struct vcd_property_hdr *property_hdr, void *property_value) { struct ddl_context *ddl_context; struct ddl_client_context *ddl = (struct ddl_client_context *) ddl_handle; u32 vcd_status = VCD_ERR_ILLEGAL_PARM; DDL_MSG_HIGH("ddl_get_property"); if (!property_hdr || !property_value) return VCD_ERR_ILLEGAL_PARM; if (property_hdr->prop_id == DDL_I_CAPABILITY) { if (sizeof(struct ddl_property_capability) == property_hdr->sz) { struct ddl_property_capability *ddl_capability = (struct ddl_property_capability *) property_value; ddl_capability->max_num_client = VCD_MAX_NO_CLIENT; ddl_capability->exclusive = VCD_COMMAND_EXCLUSIVE; ddl_capability->frame_command_depth = VCD_FRAME_COMMAND_DEPTH; ddl_capability->general_command_depth = VCD_GENEVIDC_COMMAND_DEPTH; ddl_capability->ddl_time_out_in_ms = DDL_HW_TIMEOUT_IN_MS; vcd_status = VCD_S_SUCCESS; } return vcd_status; } ddl_context = ddl_get_context(); if (!DDL_IS_INITIALIZED(ddl_context)) return VCD_ERR_ILLEGAL_OP; if (!ddl) return VCD_ERR_BAD_HANDLE; if (ddl->decoding) vcd_status = ddl_get_dec_property(ddl, property_hdr, property_value); else vcd_status = ddl_get_enc_property(ddl, property_hdr, property_value); if (vcd_status) DDL_MSG_ERROR("ddl_get_prop:FAILED"); else DDL_MSG_ERROR("ddl_get_prop:SUCCESS"); return vcd_status; }
u32 ddl_device_init(struct ddl_init_config *ddl_init_config, void *client_data) { struct ddl_context *ddl_context; u32 status = VCD_S_SUCCESS; void *ptr; DDL_MSG_HIGH("ddl_device_init"); if ((!ddl_init_config) || (!ddl_init_config->ddl_callback) || (!ddl_init_config->core_virtual_base_addr)) { DDL_MSG_ERROR("ddl_dev_init:Bad_argument"); return VCD_ERR_ILLEGAL_PARM; } ddl_context = ddl_get_context(); if (DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Multiple_init"); return VCD_ERR_ILLEGAL_OP; } if (!DDL_IS_IDLE(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Ddl_busy"); return VCD_ERR_BUSY; } memset(ddl_context, 0, sizeof(struct ddl_context)); DDL_BUSY(ddl_context); ddl_context->ddl_callback = ddl_init_config->ddl_callback; if (ddl_init_config->interrupt_clr) ddl_context->interrupt_clr = ddl_init_config->interrupt_clr; ddl_context->core_virtual_base_addr = ddl_init_config->core_virtual_base_addr; ddl_context->client_data = client_data; ddl_context->ddl_hw_response.arg1 = DDL_INVALID_INTR_STATUS; ddl_context->frame_channel_depth = VCD_FRAME_COMMAND_DEPTH; DDL_MSG_LOW("%s() : virtual address of core(%x)\n", __func__, (u32) ddl_init_config->core_virtual_base_addr); vidc_1080p_set_device_base_addr( ddl_context->core_virtual_base_addr); ddl_context->cmd_state = DDL_CMD_INVALID; ddl_client_transact(DDL_INIT_CLIENTS, NULL); ddl_context->fw_memory_size = DDL_FW_INST_GLOBAL_CONTEXT_SPACE_SIZE; ptr = ddl_pmem_alloc(&ddl_context->dram_base_a, ddl_context->fw_memory_size, DDL_KILO_BYTE(128)); if (!ptr) { DDL_MSG_ERROR("Memory Aocation Failed for FW Base"); status = VCD_ERR_ALLOC_FAIL; } else { DDL_MSG_LOW("%s() : physical address of base(%x)\n", __func__, (u32) ddl_context->dram_base_a.\ align_physical_addr); ddl_context->dram_base_b.align_physical_addr = ddl_context->dram_base_a.align_physical_addr; ddl_context->dram_base_b.align_virtual_addr = ddl_context->dram_base_a.align_virtual_addr; } if (!status && !ddl_fw_init(&ddl_context->dram_base_a)) { DDL_MSG_ERROR("ddl_dev_init:fw_init_failed"); status = VCD_ERR_ALLOC_FAIL; } if (!status) { ddl_context->cmd_state = DDL_CMD_DMA_INIT; ddl_vidc_core_init(ddl_context); } else { ddl_release_context_buffers(ddl_context); DDL_IDLE(ddl_context); } return status; }
u32 ddl_device_init(struct ddl_init_config *ddl_init_config, void *client_data) { struct ddl_context *ddl_context; u32 status = VCD_S_SUCCESS; void *ptr = NULL; DDL_MSG_HIGH("ddl_device_init"); if ((!ddl_init_config) || (!ddl_init_config->ddl_callback) || (!ddl_init_config->core_virtual_base_addr)) { DDL_MSG_ERROR("ddl_dev_init:Bad_argument"); return VCD_ERR_ILLEGAL_PARM; } ddl_context = ddl_get_context(); if (DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Multiple_init"); return VCD_ERR_ILLEGAL_OP; } if (!DDL_IS_IDLE(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Ddl_busy"); return VCD_ERR_BUSY; } memset(ddl_context, 0, sizeof(struct ddl_context)); DDL_BUSY(ddl_context); if (res_trk_get_enable_ion()) { DDL_MSG_LOW("ddl_dev_init:ION framework enabled"); ddl_context->video_ion_client = res_trk_get_ion_client(); if (!ddl_context->video_ion_client) { DDL_MSG_ERROR("ION client create failed"); return VCD_ERR_ILLEGAL_OP; } } ddl_context->ddl_callback = ddl_init_config->ddl_callback; if (ddl_init_config->interrupt_clr) ddl_context->interrupt_clr = ddl_init_config->interrupt_clr; ddl_context->core_virtual_base_addr = ddl_init_config->core_virtual_base_addr; ddl_context->client_data = client_data; ddl_context->ddl_hw_response.arg1 = DDL_INVALID_INTR_STATUS; ddl_context->frame_channel_depth = VCD_FRAME_COMMAND_DEPTH; DDL_MSG_LOW("%s() : virtual address of core(%x)\n", __func__, (u32) ddl_init_config->core_virtual_base_addr); vidc_1080p_set_device_base_addr( ddl_context->core_virtual_base_addr); ddl_context->cmd_state = DDL_CMD_INVALID; ddl_client_transact(DDL_INIT_CLIENTS, NULL); ddl_context->fw_memory_size = DDL_FW_INST_GLOBAL_CONTEXT_SPACE_SIZE; if (res_trk_get_firmware_addr(&ddl_context->dram_base_a)) { DDL_MSG_ERROR("firmware allocation failed"); ptr = NULL; } else { ptr = (void *)ddl_context->dram_base_a.virtual_base_addr; } if (!ptr) { DDL_MSG_ERROR("Memory Aocation Failed for FW Base"); status = VCD_ERR_ALLOC_FAIL; } else { DDL_MSG_LOW("%s() : physical address of base(%x)\n", __func__, (u32) ddl_context->dram_base_a.\ align_physical_addr); ddl_context->dram_base_b.align_physical_addr = ddl_context->dram_base_a.align_physical_addr; ddl_context->dram_base_b.align_virtual_addr = ddl_context->dram_base_a.align_virtual_addr; } if (!status) { if (res_trk_get_enable_sec_metadata()) { ddl_context->metadata_shared_input.mem_type = DDL_CMD_MEM; } else { ddl_context->metadata_shared_input.mem_type = DDL_FW_MEM; } ptr = ddl_pmem_alloc(&ddl_context->metadata_shared_input, DDL_METADATA_TOTAL_INPUTBUFSIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); if (!ptr) { DDL_MSG_ERROR("ddl_device_init: metadata alloc fail"); status = VCD_ERR_ALLOC_FAIL; } } if (!status && !ddl_fw_init(&ddl_context->dram_base_a)) { DDL_MSG_ERROR("ddl_dev_init:fw_init_failed"); status = VCD_ERR_ALLOC_FAIL; } if (!status) { ddl_context->cmd_state = DDL_CMD_DMA_INIT; ddl_vidc_core_init(ddl_context); } else { ddl_release_context_buffers(ddl_context); DDL_IDLE(ddl_context); } return status; }
static u32 ddl_decoder_seq_done_callback(struct ddl_context *ddl_context, struct ddl_client_context *ddl) { struct ddl_decoder_data *decoder = &ddl->codec_data.decoder; struct vidc_1080p_seq_hdr_info seq_hdr_info; u32 process_further = true; struct ddl_profile_info_type disp_profile_info; /*HTC_START Fix Klocwork issue*/ seq_hdr_info.profile = 0; seq_hdr_info.level = 0; /*HTC_END*/ DDL_MSG_MED("ddl_decoder_seq_done_callback"); if (!ddl->decoding || !DDLCLIENT_STATE_IS(ddl, DDL_CLIENT_WAIT_FOR_INITCODECDONE)) { DDL_MSG_ERROR("STATE-CRITICAL-HDDONE"); ddl_client_fatal_cb(ddl); } else { if (vidc_msg_timing) ddl_calc_core_proc_time(__func__, DEC_OP_TIME); ddl->cmd_state = DDL_CMD_INVALID; DDL_MSG_LOW("ddl_state_transition: %s ~~>" "DDL_CLIENT_WAIT_FOR_DPB", ddl_get_state_string(ddl->client_state)); ddl->client_state = DDL_CLIENT_WAIT_FOR_DPB; DDL_MSG_LOW("HEADER_DONE"); vidc_1080p_get_decode_seq_start_result(&seq_hdr_info); parse_hdr_size_data(ddl, &seq_hdr_info); if (!seq_hdr_info.img_size_x || !seq_hdr_info.img_size_y) { DDL_MSG_ERROR("FATAL:ZeroImageSize"); ddl_client_fatal_cb(ddl); return process_further; } vidc_sm_get_profile_info(&ddl->shared_mem [ddl->command_channel], &disp_profile_info); disp_profile_info.pic_profile = seq_hdr_info.profile; disp_profile_info.pic_level = seq_hdr_info.level; ddl_get_dec_profile_level(decoder, seq_hdr_info.profile, seq_hdr_info.level); switch (decoder->codec.codec) { case VCD_CODEC_H264: if (decoder->profile.profile == VCD_PROFILE_H264_HIGH || decoder->profile.profile == VCD_PROFILE_UNKNOWN) { if ((disp_profile_info.chroma_format_idc > VIDC_1080P_IDCFORMAT_420) || (disp_profile_info.bit_depth_luma_minus8 || disp_profile_info. bit_depth_chroma_minus8)) { DDL_MSG_ERROR("Unsupported H.264 " "feature: IDC " "format : %d, Bitdepth: %d", disp_profile_info. chroma_format_idc, (disp_profile_info. bit_depth_luma_minus8 || disp_profile_info. bit_depth_chroma_minus8)); ddl_client_fatal_cb(ddl); return process_further; } } break; case VCD_CODEC_MPEG4: case VCD_CODEC_DIVX_4: case VCD_CODEC_DIVX_5: case VCD_CODEC_DIVX_6: case VCD_CODEC_XVID: if (seq_hdr_info.data_partition) if ((seq_hdr_info.img_size_x * seq_hdr_info.img_size_y) > (720 * 576)) { DDL_MSG_ERROR("Unsupported DP clip"); ddl_client_fatal_cb(ddl); return process_further; } break; default: break; } ddl_calculate_stride(&decoder->frame_size, !decoder->progressive_only); decoder->frame_size.scan_lines = DDL_ALIGN(decoder->frame_size.height, DDL_TILE_ALIGN_HEIGHT); decoder->frame_size.stride = DDL_ALIGN(decoder->frame_size.width, DDL_TILE_ALIGN_WIDTH); parse_hdr_crop_data(ddl, &seq_hdr_info); if (decoder->codec.codec == VCD_CODEC_H264 && seq_hdr_info.level > VIDC_1080P_H264_LEVEL4) { DDL_MSG_ERROR("WARNING: H264MaxLevelExceeded : %d", seq_hdr_info.level); } ddl_set_default_decoder_buffer_req(decoder, false); if (decoder->header_in_start) { if (!(decoder->cont_mode) || (decoder->min_dpb_num > decoder->client_output_buf_req.min_count) || (decoder->actual_output_buf_req.sz > decoder->client_output_buf_req.sz)) { decoder->client_frame_size = decoder->frame_size; decoder->client_output_buf_req = decoder->actual_output_buf_req; decoder->client_input_buf_req = decoder->actual_input_buf_req; } ddl_context->ddl_callback(VCD_EVT_RESP_START, VCD_S_SUCCESS, NULL, 0, (u32 *) ddl, ddl->client_data); ddl_release_command_channel(ddl_context, ddl->command_channel); } else { u32 seq_hdr_only_frame = false; u32 need_reconfig = false; struct vcd_frame_data *input_vcd_frm = &ddl->input_frame.vcd_frm; need_reconfig = ddl_check_reconfig(ddl); DDL_MSG_HIGH("%s : need_reconfig = %u\n", __func__, need_reconfig); if (input_vcd_frm->flags & VCD_FRAME_FLAG_EOS) { need_reconfig = false; } if (((input_vcd_frm->flags & VCD_FRAME_FLAG_CODECCONFIG) && (!(input_vcd_frm->flags & VCD_FRAME_FLAG_SYNCFRAME))) || input_vcd_frm->data_len <= seq_hdr_info.dec_frm_size) { seq_hdr_only_frame = true; input_vcd_frm->offset += seq_hdr_info.dec_frm_size; input_vcd_frm->data_len = 0; input_vcd_frm->flags |= VCD_FRAME_FLAG_CODECCONFIG; ddl->input_frame.frm_trans_end = !need_reconfig; ddl_context->ddl_callback( VCD_EVT_RESP_INPUT_DONE, VCD_S_SUCCESS, &ddl->input_frame, sizeof(struct ddl_frame_data_tag), (u32 *) ddl, ddl->client_data); } else { if (decoder->codec.codec == VCD_CODEC_VC1_RCV) { vidc_sm_set_start_byte_number( &ddl->shared_mem [ddl->command_channel], seq_hdr_info.dec_frm_size); } } if (need_reconfig) { struct ddl_frame_data_tag *payload = &ddl->input_frame; u32 payload_size = sizeof(struct ddl_frame_data_tag); decoder->client_frame_size = decoder->frame_size; decoder->client_output_buf_req = decoder->actual_output_buf_req; decoder->client_input_buf_req = decoder->actual_input_buf_req; if (seq_hdr_only_frame) { payload = NULL; payload_size = 0; } DDL_MSG_HIGH("%s : sending port reconfig\n", __func__); ddl_context->ddl_callback( VCD_EVT_IND_OUTPUT_RECONFIG, VCD_S_SUCCESS, payload, payload_size, (u32 *) ddl, ddl->client_data); } if (!need_reconfig && !seq_hdr_only_frame) { if (!ddl_vidc_decode_set_buffers(ddl)) process_further = false; else { DDL_MSG_ERROR("ddl_vidc_decode_set_" "buffers failed"); ddl_client_fatal_cb(ddl); } } else ddl_release_command_channel(ddl_context, ddl->command_channel); } } return process_further; }
static u32 ddl_get_encoded_frame(struct vcd_frame_data *frame, enum vcd_codec codec, enum vidc_1080p_encode_frame frame_type) { u32 status = true; if (codec == VCD_CODEC_H264) { switch (frame_type) { case VIDC_1080P_ENCODE_FRAMETYPE_NOT_CODED: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_I: frame->flags |= VCD_FRAME_FLAG_SYNCFRAME; frame->frame = VCD_FRAME_I; break; case VIDC_1080P_ENCODE_FRAMETYPE_P: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_B: frame->frame = VCD_FRAME_B; frame->flags |= VCD_FRAME_FLAG_BFRAME; break; case VIDC_1080P_ENCODE_FRAMETYPE_SKIPPED: frame->frame = VCD_FRAME_NOTCODED; frame->data_len = 0; break; case VIDC_1080P_ENCODE_FRAMETYPE_OTHERS: DDL_MSG_LOW("FRAMETYPE-OTHERS"); break; case VIDC_1080P_ENCODE_FRAMETYPE_32BIT: default: DDL_MSG_LOW("UNKNOWN-FRAMETYPE"); status = false; break; } } else if (codec == VCD_CODEC_MPEG4) { switch (frame_type) { case VIDC_1080P_ENCODE_FRAMETYPE_NOT_CODED: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_I: frame->flags |= VCD_FRAME_FLAG_SYNCFRAME; frame->frame = VCD_FRAME_I; break; case VIDC_1080P_ENCODE_FRAMETYPE_P: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_B: frame->frame = VCD_FRAME_B; frame->flags |= VCD_FRAME_FLAG_BFRAME; break; case VIDC_1080P_ENCODE_FRAMETYPE_SKIPPED: frame->frame = VCD_FRAME_NOTCODED; frame->data_len = 0; break; case VIDC_1080P_ENCODE_FRAMETYPE_OTHERS: DDL_MSG_LOW("FRAMETYPE-OTHERS"); break; case VIDC_1080P_ENCODE_FRAMETYPE_32BIT: default: DDL_MSG_LOW("UNKNOWN-FRAMETYPE"); status = false; break; } } else if (codec == VCD_CODEC_H263) { switch (frame_type) { case VIDC_1080P_ENCODE_FRAMETYPE_NOT_CODED: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_I: frame->flags |= VCD_FRAME_FLAG_SYNCFRAME; frame->frame = VCD_FRAME_I; break; case VIDC_1080P_ENCODE_FRAMETYPE_P: frame->frame = VCD_FRAME_P; break; case VIDC_1080P_ENCODE_FRAMETYPE_SKIPPED: frame->frame = VCD_FRAME_NOTCODED; frame->data_len = 0; break; case VIDC_1080P_ENCODE_FRAMETYPE_OTHERS: DDL_MSG_LOW("FRAMETYPE-OTHERS"); break; case VIDC_1080P_ENCODE_FRAMETYPE_32BIT: default: DDL_MSG_LOW("UNKNOWN-FRAMETYPE"); status = false; break; } } else status = false; DDL_MSG_HIGH("Enc Frame Type %u", (u32)frame->frame); return status; }
u32 ddl_device_init(struct ddl_init_config *ddl_init_config, void *client_data) { struct ddl_context *ddl_context; struct res_trk_firmware_addr firmware_addr; u32 status = VCD_S_SUCCESS, memorytype = PMEM_MEMTYPE; void *ptr = NULL; DDL_MSG_HIGH("ddl_device_init"); if ((!ddl_init_config) || (!ddl_init_config->ddl_callback) || (!ddl_init_config->core_virtual_base_addr)) { DDL_MSG_ERROR("ddl_dev_init:Bad_argument"); return VCD_ERR_ILLEGAL_PARM; } ddl_context = ddl_get_context(); if (DDL_IS_INITIALIZED(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Multiple_init"); return VCD_ERR_ILLEGAL_OP; } if (!DDL_IS_IDLE(ddl_context)) { DDL_MSG_ERROR("ddl_dev_init:Ddl_busy"); return VCD_ERR_BUSY; } memset(ddl_context, 0, sizeof(struct ddl_context)); DDL_BUSY(ddl_context); ddl_context->ddl_callback = ddl_init_config->ddl_callback; if (ddl_init_config->interrupt_clr) ddl_context->interrupt_clr = ddl_init_config->interrupt_clr; ddl_context->core_virtual_base_addr = ddl_init_config->core_virtual_base_addr; ddl_context->client_data = client_data; ddl_context->ddl_hw_response.arg1 = DDL_INVALID_INTR_STATUS; ddl_context->frame_channel_depth = VCD_FRAME_COMMAND_DEPTH; DDL_MSG_LOW("%s() : virtual address of core(%x)\n", __func__, (u32) ddl_init_config->core_virtual_base_addr); vidc_1080p_set_device_base_addr( ddl_context->core_virtual_base_addr); ddl_context->cmd_state = DDL_CMD_INVALID; ddl_client_transact(DDL_INIT_CLIENTS, NULL); ddl_context->fw_memory_size = DDL_FW_INST_GLOBAL_CONTEXT_SPACE_SIZE; if (memorytype == PMEM_MEMTYPE_SMI) { ptr = ddl_pmem_alloc(&ddl_context->dram_base_a, ddl_context->fw_memory_size, DDL_KILO_BYTE(128)); } else { if (!res_trk_get_firmware_addr(&firmware_addr) && firmware_addr.buf_size >= ddl_context->fw_memory_size) { if (DDL_ADDR_IS_ALIGNED(firmware_addr.device_addr, DDL_KILO_BYTE(128))) { ptr = (void *) firmware_addr.base_addr; ddl_context->dram_base_a.physical_base_addr = ddl_context->dram_base_a.align_physical_addr = (u8 *)firmware_addr.device_addr; ddl_context->dram_base_a.align_virtual_addr = ddl_context->dram_base_a.virtual_base_addr = firmware_addr.base_addr; ddl_context->dram_base_a.buffer_size = ddl_context->fw_memory_size; } else { DDL_MSG_ERROR("firmware base not aligned %p", (void *)firmware_addr.device_addr); } } } if (!ptr) { DDL_MSG_ERROR("Memory Aocation Failed for FW Base"); status = VCD_ERR_ALLOC_FAIL; } else { DDL_MSG_LOW("%s() : physical address of base(%x)\n", __func__, (u32) ddl_context->dram_base_a.\ align_physical_addr); ddl_context->dram_base_b.align_physical_addr = ddl_context->dram_base_a.align_physical_addr; ddl_context->dram_base_b.align_virtual_addr = ddl_context->dram_base_a.align_virtual_addr; } if (!status) { ptr = ddl_pmem_alloc(&ddl_context->metadata_shared_input, DDL_METADATA_TOTAL_INPUTBUFSIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); if (!ptr) { DDL_MSG_ERROR("ddl_device_init: metadata alloc fail"); status = VCD_ERR_ALLOC_FAIL; } } if (!status && !ddl_fw_init(&ddl_context->dram_base_a)) { DDL_MSG_ERROR("ddl_dev_init:fw_init_failed"); status = VCD_ERR_ALLOC_FAIL; } if (!status && memorytype == PMEM_MEMTYPE_EBI1) clean_caches((unsigned long)firmware_addr.base_addr, firmware_addr.buf_size, firmware_addr.device_addr); if (!status) { ddl_context->cmd_state = DDL_CMD_DMA_INIT; ddl_vidc_core_init(ddl_context); } else { ddl_release_context_buffers(ddl_context); DDL_IDLE(ddl_context); } return status; }
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"); if (vidc_msg_timing) { if (first_time < 2) { ddl_reset_core_time_variables(ENC_OP_TIME); first_time++; } ddl_set_core_start_time(__func__, ENC_OP_TIME); } 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 if ((encoder->codec.codec == VCD_CODEC_MPEG4 && !encoder->short_header.short_header) || encoder->codec.codec == VCD_CODEC_H264) { 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; } } else { encoder->seq_header.buffer_size = 0; encoder->seq_header.virtual_base_addr = 0; encoder->seq_header.align_physical_addr = 0; encoder->seq_header.align_virtual_addr = 0; } if (!ddl_take_command_channel(ddl_context, ddl, client_data)) return VCD_ERR_BUSY; ddl_vidc_channel_set(ddl); return status; }
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"); if (first_time < 2) { ddl_reset_core_time_variables(ENC_OP_TIME); first_time++; } ddl_set_core_start_time(__func__, ENC_OP_TIME); 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; if (DDL_IS_LTR_ENABLED(encoder)) { DDL_MSG_HIGH("LTR enabled, mode %u count %u", (u32)encoder->ltr_control.ltrmode.ltr_mode, (u32)encoder->ltr_control.ltr_count); status = ddl_allocate_ltr_list(&encoder->ltr_control); if (status) { DDL_MSG_ERROR("%s: allocate ltr list failed", __func__); return status; } else { ddl_clear_ltr_list(&encoder->ltr_control, false); } encoder->num_references_for_p_frame = 2; encoder->ltr_control.callback_reqd = false; encoder->ltr_control.curr_ltr_id = (u32)DDL_LTR_FRAME_START_ID; DDL_MSG_HIGH("num_ref_for_p_frames %u, curr_ltr_id = %u", (u32)encoder->num_references_for_p_frame, (u32)encoder->ltr_control.curr_ltr_id); } status = ddl_allocate_enc_hw_buffers(ddl); if (status) return status; #ifdef DDL_BUF_LOG ddl_list_buffers(ddl); #endif encoder->seq_header.mem_type = DDL_MM_MEM; 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; } msm_ion_do_cache_op(ddl_context->video_ion_client, encoder->seq_header.alloc_handle, encoder->seq_header.virtual_base_addr, encoder->seq_header.buffer_size, ION_IOC_CLEAN_INV_CACHES); if (encoder->slice_delivery_info.enable) { DDL_MSG_LOW("%s: slice mode allocate memory for struct\n", __func__); ptr = ddl_pmem_alloc(&encoder->batch_frame.slice_batch_in, DDL_ENC_SLICE_BATCH_INPSTRUCT_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); if (ptr) { ptr = ddl_pmem_alloc( &encoder->batch_frame.slice_batch_out, DDL_ENC_SLICE_BATCH_OUTSTRUCT_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); } if (!ptr) { ddl_pmem_free(&encoder->batch_frame.slice_batch_in); ddl_pmem_free(&encoder->batch_frame.slice_batch_out); ddl_free_enc_hw_buffers(ddl); ddl_pmem_free(&encoder->seq_header); DDL_MSG_ERROR("ddlEncStart:SeqHdrAllocFailed"); 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_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"); if (vidc_msg_timing) { if (first_time < 2) { ddl_reset_core_time_variables(ENC_OP_TIME); first_time++; } ddl_set_core_start_time(__func__, ENC_OP_TIME); } 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 #ifdef CONFIG_MSM_MULTIMEDIA_USE_ION encoder->seq_header.mem_type = DDL_MM_MEM; #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 (encoder->slice_delivery_info.enable) { DDL_MSG_LOW("%s: slice mode allocate memory for struct\n", __func__); ptr = ddl_pmem_alloc(&encoder->batch_frame.slice_batch_in, DDL_ENC_SLICE_BATCH_INPSTRUCT_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); if (ptr) { ptr = ddl_pmem_alloc( &encoder->batch_frame.slice_batch_out, DDL_ENC_SLICE_BATCH_OUTSTRUCT_SIZE, DDL_LINEAR_BUFFER_ALIGN_BYTES); } if (!ptr) { ddl_pmem_free(&encoder->batch_frame.slice_batch_in); ddl_pmem_free(&encoder->batch_frame.slice_batch_out); ddl_free_enc_hw_buffers(ddl); ddl_pmem_free(&encoder->seq_header); DDL_MSG_ERROR("ddlEncStart:SeqHdrAllocFailed"); 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_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"); 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_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"); if (vidc_msg_timing) ddl_set_core_start_time(__func__, ENC_OP_TIME); 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; }
static u32 ddl_decoder_output_done_callback( struct ddl_client_context *ddl, u32 frame_transact_end) { struct ddl_context *ddl_context = ddl->ddl_context; struct ddl_decoder_data *decoder = &(ddl->codec_data.decoder); struct vidc_1080p_dec_disp_info *dec_disp_info = &(decoder->dec_disp_info); struct ddl_frame_data_tag *output_frame = &(ddl->output_frame); struct vcd_frame_data *output_vcd_frm = &(output_frame->vcd_frm); u32 vcd_status, free_luma_dpb = 0, disp_pict = 0, is_interlaced; get_dec_op_done_data(dec_disp_info, decoder->output_order, &output_vcd_frm->physical, &is_interlaced); decoder->progressive_only = !(is_interlaced); output_vcd_frm->frame = VCD_FRAME_YUV; if (decoder->codec.codec == VCD_CODEC_MPEG4 || decoder->codec.codec == VCD_CODEC_VC1 || decoder->codec.codec == VCD_CODEC_VC1_RCV || (decoder->codec.codec >= VCD_CODEC_DIVX_3 && decoder->codec.codec <= VCD_CODEC_XVID)) { vidc_sm_get_displayed_picture_frame(&ddl->shared_mem [ddl->command_channel], &disp_pict); if (decoder->output_order == VCD_DEC_ORDER_DISPLAY) { if (!disp_pict) { output_vcd_frm->frame = VCD_FRAME_NOTCODED; vidc_sm_get_available_luma_dpb_address( &ddl->shared_mem[ddl->command_channel], &free_luma_dpb); } } else { if (dec_disp_info->input_frame == VIDC_1080P_DECODE_FRAMETYPE_NOT_CODED) { output_vcd_frm->frame = VCD_FRAME_NOTCODED; vidc_sm_get_available_luma_dpb_dec_order_address( &ddl->shared_mem[ddl->command_channel], &free_luma_dpb); } } if (free_luma_dpb) output_vcd_frm->physical = (u8 *)(free_luma_dpb << 11); } vcd_status = ddl_decoder_dpb_transact(decoder, output_frame, DDL_DPB_OP_MARK_BUSY); if (vcd_status) { DDL_MSG_ERROR("CORRUPTED_OUTPUT_BUFFER_ADDRESS"); ddl_hw_fatal_cb(ddl); } else { vidc_sm_get_metadata_status(&ddl->shared_mem [ddl->command_channel], &decoder->meta_data_exists); if (decoder->output_order == VCD_DEC_ORDER_DISPLAY) vidc_sm_get_frame_tags(&ddl->shared_mem [ddl->command_channel], &dec_disp_info->tag_top, &dec_disp_info->tag_bottom); output_vcd_frm->ip_frm_tag = dec_disp_info->tag_top; vidc_sm_get_picture_times(&ddl->shared_mem [ddl->command_channel], &dec_disp_info->pic_time_top, &dec_disp_info->pic_time_bottom); get_dec_op_done_crop(decoder->output_order, dec_disp_info, &output_vcd_frm->dec_op_prop.disp_frm, &output_vcd_frm->dec_op_prop.frm_size, &decoder->frame_size, &ddl->shared_mem[ddl_context->response_cmd_ch_id]); if ((decoder->cont_mode) && ((output_vcd_frm->dec_op_prop.frm_size.width != decoder->frame_size.width) || (output_vcd_frm->dec_op_prop.frm_size.height != decoder->frame_size.height) || (decoder->frame_size.width != decoder->client_frame_size.width) || (decoder->frame_size.height != decoder->client_frame_size.height))) { DDL_MSG_LOW("%s o/p width = %u o/p height = %u" "decoder width = %u decoder height = %u ", __func__, output_vcd_frm->dec_op_prop.frm_size.width, output_vcd_frm->dec_op_prop.frm_size.height, decoder->frame_size.width, decoder->frame_size.height); DDL_MSG_HIGH("%s Sending INFO_OP_RECONFIG event\n", __func__); ddl_context->ddl_callback( VCD_EVT_IND_INFO_OUTPUT_RECONFIG, VCD_S_SUCCESS, NULL, 0, (u32 *)ddl, ddl->client_data); decoder->frame_size = output_vcd_frm->dec_op_prop.frm_size; decoder->client_frame_size = decoder->frame_size; decoder->y_cb_cr_size = ddl_get_yuv_buffer_size(&decoder->frame_size, &decoder->buf_format, (!decoder->progressive_only), decoder->codec.codec, NULL); decoder->actual_output_buf_req.sz = decoder->y_cb_cr_size + decoder->suffix; decoder->min_output_buf_req = decoder->actual_output_buf_req; DDL_MSG_LOW("%s y_cb_cr_size = %u " "actual_output_buf_req.sz = %u" "min_output_buf_req.sz = %u\n", decoder->y_cb_cr_size, decoder->actual_output_buf_req.sz, decoder->min_output_buf_req.sz); vidc_sm_set_chroma_addr_change( &ddl->shared_mem[ddl->command_channel], false); } output_vcd_frm->interlaced = is_interlaced; output_vcd_frm->intrlcd_ip_frm_tag = (!is_interlaced || !dec_disp_info->tag_bottom) ? VCD_FRAMETAG_INVALID : dec_disp_info->tag_bottom; output_vcd_frm->offset = 0; output_vcd_frm->data_len = decoder->y_cb_cr_size; if (free_luma_dpb) { output_vcd_frm->data_len = 0; output_vcd_frm->flags |= VCD_FRAME_FLAG_DECODEONLY; } output_vcd_frm->flags |= VCD_FRAME_FLAG_ENDOFFRAME; output_frame->frm_trans_end = frame_transact_end; if (vidc_msg_timing) ddl_calc_core_proc_time(__func__, DEC_OP_TIME); ddl_process_decoder_metadata(ddl); ddl_context->ddl_callback(VCD_EVT_RESP_OUTPUT_DONE, vcd_status, output_frame, sizeof(struct ddl_frame_data_tag), (u32 *)ddl, ddl->client_data); } return vcd_status; }
void vidc_sm_get_aspect_ratio_info(struct ddl_buf_addr *shared_mem, enum vcd_codec codec, struct vcd_aspect_ratio *aspect_ratio_info) { u32 extended_par_info = 0, aspect_ratio = 0; aspect_ratio = DDL_MEM_READ_32(shared_mem, VIDC_SM_ASPECT_RATIO_INFO_ADDR); if (codec == VCD_CODEC_H264) { aspect_ratio_info->aspect_ratio = VIDC_GETFIELD(aspect_ratio, VIDC_SM_H264_ASPECT_RATIO_INFO_BMSK, VIDC_SM_H264_ASPECT_RATIO_INFO_SHFT); switch (aspect_ratio_info->aspect_ratio) { case 1: aspect_ratio_info->par_width = 1; aspect_ratio_info->par_height = 1; break; case 2: aspect_ratio_info->par_width = 12; aspect_ratio_info->par_height = 11; break; case 3: aspect_ratio_info->par_width = 10; aspect_ratio_info->par_height = 11; break; case 4: aspect_ratio_info->par_width = 16; aspect_ratio_info->par_height = 11; break; case 5: aspect_ratio_info->par_width = 40; aspect_ratio_info->par_height = 33; break; case 6: aspect_ratio_info->par_width = 24; aspect_ratio_info->par_height = 11; break; case 7: aspect_ratio_info->par_width = 20; aspect_ratio_info->par_height = 11; break; case 8: aspect_ratio_info->par_width = 32; aspect_ratio_info->par_height = 11; break; case 9: aspect_ratio_info->par_width = 80; aspect_ratio_info->par_height = 33; break; case 10: aspect_ratio_info->par_width = 18; aspect_ratio_info->par_height = 11; break; case 11: aspect_ratio_info->par_width = 15; aspect_ratio_info->par_height = 11; break; case 12: aspect_ratio_info->par_width = 64; aspect_ratio_info->par_height = 33; break; case 13: aspect_ratio_info->par_width = 160; aspect_ratio_info->par_height = 99; break; case 14: aspect_ratio_info->par_width = 4; aspect_ratio_info->par_height = 3; break; case 15: aspect_ratio_info->par_width = 3; aspect_ratio_info->par_height = 2; break; case 16: aspect_ratio_info->par_width = 2; aspect_ratio_info->par_height = 1; break; case 255: extended_par_info = DDL_MEM_READ_32(shared_mem, VIDC_SM_EXTENDED_PAR_ADDR); aspect_ratio_info->par_width = VIDC_GETFIELD(extended_par_info, VIDC_SM_EXTENDED_PAR_WIDTH_BMSK, VIDC_SM_EXTENDED_PAR_WIDTH_SHFT); aspect_ratio_info->par_height = VIDC_GETFIELD(extended_par_info, VIDC_SM_EXTENDED_PAR_HEIGHT_BMSK, VIDC_SM_EXTENDED_PAR_HEIGHT_SHFT); break; default: DDL_MSG_HIGH("Incorrect Aspect Ratio."); aspect_ratio_info->par_width = 1; aspect_ratio_info->par_height = 1; break; } } else if ((codec == VCD_CODEC_MPEG4) || (codec == VCD_CODEC_DIVX_4) || (codec == VCD_CODEC_DIVX_5) || (codec == VCD_CODEC_DIVX_6) || (codec == VCD_CODEC_XVID) || (codec == VCD_CODEC_MPEG2)) { if (codec == VCD_CODEC_MPEG2) { aspect_ratio_info->aspect_ratio = VIDC_GETFIELD(aspect_ratio, VIDC_SM_MPEG2_ASPECT_RATIO_INFO_BMSK, VIDC_SM_MPEG2_ASPECT_RATIO_INFO_SHFT); } else { aspect_ratio_info->aspect_ratio = VIDC_GETFIELD(aspect_ratio, VIDC_SM_MPEG4_ASPECT_RATIO_INFO_BMSK, VIDC_SM_MPEG4_ASPECT_RATIO_INFO_SHFT); } switch (aspect_ratio_info->aspect_ratio) { case 1: aspect_ratio_info->par_width = 1; aspect_ratio_info->par_height = 1; break; case 2: aspect_ratio_info->par_width = 12; aspect_ratio_info->par_height = 11; break; case 3: aspect_ratio_info->par_width = 10; aspect_ratio_info->par_height = 11; break; case 4: aspect_ratio_info->par_width = 16; aspect_ratio_info->par_height = 11; break; case 5: aspect_ratio_info->par_width = 40; aspect_ratio_info->par_height = 33; break; case 15: extended_par_info = DDL_MEM_READ_32(shared_mem, VIDC_SM_EXTENDED_PAR_ADDR); aspect_ratio_info->par_width = VIDC_GETFIELD(extended_par_info, VIDC_SM_EXTENDED_PAR_WIDTH_BMSK, VIDC_SM_EXTENDED_PAR_WIDTH_SHFT); aspect_ratio_info->par_height = VIDC_GETFIELD(extended_par_info, VIDC_SM_EXTENDED_PAR_HEIGHT_BMSK, VIDC_SM_EXTENDED_PAR_HEIGHT_SHFT); break; default: DDL_MSG_HIGH("Incorrect Aspect Ratio."); aspect_ratio_info->par_width = 1; aspect_ratio_info->par_height = 1; break; } } }