/*================================================================================================ TTX internal founctions =================================================================================================*/ static void _ttx_ctrl_reset(ttx_ctrl_t *p_ttx) { _subt_ttx_ctrl_lock(get_priv()); memset(p_ttx->m_ui_lang, 0, SUBT_TTX_CTRL_LANG_LEN * sizeof(u8)); memset(p_ttx->cur_lang, 0, SUBT_TTX_CTRL_LANG_LEN * sizeof(u8)); memset(p_ttx->m_dr, 0, SUBT_TTX_CTRL_LANG_LEN * sizeof(teletext_descr_t)); p_ttx->m_cnt = 0; _subt_ttx_ctrl_unlock(get_priv()); }
/*================================================================================================ SUBT internal founctions =================================================================================================*/ static void _subt_ctrl_reset(subt_ctrl_t *p_subt) { _subt_ttx_ctrl_lock(get_priv()); memset(p_subt->m_ui_lang, 0, SUBT_TTX_CTRL_LANG_LEN * sizeof(u8)); memset(p_subt->m_dr, 0, SUBT_TTX_CTRL_LANG_LEN * sizeof(subtitle_descr_t)); p_subt->m_cnt = 0; _subt_ttx_ctrl_unlock(get_priv()); }
void subt_station_out_config(handle_t _this, str_align_t align) { subt_station_out_pin_priv_t *p_priv = get_priv(_this); p_priv->align = align; }
static RET_CODE fsrc_pin_on_open(handle_t _this) { fsrc_pin_private_t *p_priv = get_priv(_this); if (p_priv->buf_get) { return SUCCESS; } if (p_priv->is_share) { p_priv->file = p_priv->p_vfs->open((u8 *)p_priv->file_name, VFS_SHARE); } else { p_priv->file = p_priv->p_vfs->open((u8 *)p_priv->file_name, VFS_READ); } if (p_priv->file != NULL) { return SUCCESS; } else { return ERR_FAILURE; } }
/*! subt_ctrl_hide \return SUCCESS if no error */ RET_CODE subt_ctrl_hide(void) { subt_ttx_ctrl_priv_t *p_this = NULL; do { p_this = get_priv(); ERR_POINT(p_this); p_this->m_subt_ctrl.enable = FALSE; if(p_this->m_subt_ctrl.m_subt_start) { p_this->m_subt_ctrl.m_subt_start = FALSE; memset(&p_this->m_subt_ctrl.cur_subt_dr, 0, sizeof(subtitle_descr_t)); return mul_subtitle_stop_decode(); } if(p_this->m_subt_ctrl.m_ttx_start) { p_this->m_subt_ctrl.m_ttx_start = FALSE; memset(&p_this->m_subt_ctrl.cur_ttx_dr, 0, sizeof(teletext_descr_t)); return ttx_ctrl_hide(); } }while(0); return ERR_FAILURE; }
/*! subt_ctrl_ui_enable \param[in] p_lang: language for subtitle to show \return SUCCESS if no error */ RET_CODE subt_ctrl_prepare_for_subt(u8 *p_lang, subt_ttx_type_t type, subt_ctrl_call_back pre_open) { subt_ctrl_t *p_subt = NULL; subt_ttx_ctrl_priv_t *p_this = NULL; do { ERR_POINT(p_lang); p_this = get_priv(); ERR_POINT(p_this); p_subt = &p_this->m_subt_ctrl; memcpy(p_subt->m_ui_lang, p_lang, SUBT_TTX_CTRL_LANG_LEN - 1); p_subt->wait_type = type; p_subt->enable = TRUE; p_subt->ttx_type_subt_cb = pre_open; return SUCCESS; }while(0); return ERR_FAILURE; }
static void fsrc_pin_set_buffer_read(handle_t _this, u32 read_data) { fsrc_pin_private_t *p_priv = get_priv(_this); p_priv->buf_get = (buffer_get) read_data; p_priv->file_name[0] = 0; }
static struct snobj *queue_out_init(struct module *m, struct snobj *arg) { struct queue_out_priv *priv = get_priv(m); struct snobj *t; const char *port_name; int ret; if (!arg || snobj_type(arg) != TYPE_MAP) return snobj_err(EINVAL, "Argument must be a map"); t = snobj_eval(arg, "port"); if (!t || !(port_name = snobj_str_get(t))) return snobj_err(EINVAL, "Field 'port' must be specified"); t = snobj_eval(arg, "qid"); if (!t || snobj_type(t) != TYPE_INT) return snobj_err(EINVAL, "Field 'qid' must be specified"); priv->qid = snobj_uint_get(t); priv->port = find_port(port_name); if (!priv->port) return snobj_err(ENODEV, "Port %s not found", port_name); ret = acquire_queues(priv->port, m, PACKET_DIR_OUT, &priv->qid, 1); if (ret < 0) return snobj_errno(-ret); priv->send_pkts = priv->port->driver->send_pkts; return NULL; }
static void queue_out_process_batch(struct module *m, struct pkt_batch *batch) { struct queue_out_priv *priv = get_priv(m); struct port *p = priv->port; const queue_t qid = priv->qid; uint64_t sent_bytes = 0; int sent_pkts; sent_pkts = priv->send_pkts(p, qid, batch->pkts, batch->cnt); if (!(p->driver->flags & DRIVER_FLAG_SELF_OUT_STATS)) { const packet_dir_t dir = PACKET_DIR_OUT; for (int i = 0; i < sent_pkts; i++) sent_bytes += snb_total_len(batch->pkts[i]); p->queue_stats[dir][qid].packets += sent_pkts; p->queue_stats[dir][qid].dropped += (batch->cnt - sent_pkts); p->queue_stats[dir][qid].bytes += sent_bytes; } if (sent_pkts < batch->cnt) snb_free_bulk(batch->pkts + sent_pkts, batch->cnt - sent_pkts); }
void subt_ttx_ctrl_set_pg_id(u16 pg_id) { subt_ttx_ctrl_priv_t *p_this = NULL; p_this = get_priv(); p_this->pg_id = pg_id; }
static void _ttx_ctrl_auto(void) { teletext_descr_t *p_ttx_dr = NULL; ttx_ctrl_t *p_ttx = NULL; subt_ttx_ctrl_priv_t *p_this = get_priv(); p_ttx = &p_this->m_ttx_ctrl; if(p_ttx->m_start == TRUE) { p_ttx_dr = _ttx_ctrl_match_dr(p_ttx, p_ttx->m_ui_lang); if(p_ttx_dr != NULL && memcmp(p_ttx->cur_lang, p_ttx_dr->language_code, 3)) { memcpy(p_ttx->cur_lang, p_ttx_dr->language_code, 3); mul_teletext_reset_pid(p_ttx_dr->pid); } else if(p_ttx->m_cnt > 0) { p_ttx_dr = &p_ttx->m_dr[0]; if(memcmp(p_ttx->cur_lang, p_ttx_dr->language_code, 3)) { memcpy(p_ttx->cur_lang, p_ttx_dr->language_code, 3); mul_teletext_reset_pid(p_ttx_dr->pid); } } } }
lrc_in_pin_t *lrc_in_pin_create(lrc_in_pin_t *p_in_pin, interface_t *p_owner) { lrc_in_pin_private_t *p_priv = NULL; base_input_pin_t *p_input_pin = NULL; ipin_t *p_ipin = NULL; //interface_t *p_interface = NULL; transf_input_pin_para_t para; media_format_t media_format = {MT_FILE_DATA}; CHECK_FAIL_RET_NULL(p_in_pin != NULL); para.p_filter = p_owner; para.p_name = "lrc_in_pin"; //create base class transf_input_pin_create(&p_in_pin->m_pin, ¶); //init private date p_priv = get_priv((handle_t)p_in_pin); p_priv->p_this = p_in_pin; p_input_pin = (base_input_pin_t *)p_in_pin; p_input_pin->notify_allocator = notify_allocator; p_ipin = (ipin_t *)p_in_pin; p_ipin->on_open = lrc_in_pin_on_open; p_ipin->on_start = lrc_in_pin_on_start; p_ipin->add_supported_media_format(p_ipin, &media_format); return p_in_pin; }
/*! ttx_ctrl_show \param[in] lang_idx: language index of teletext \return SUCCESS if no error */ RET_CODE ttx_ctrl_start(u8 *p_lang) { RET_CODE ret = ERR_FAILURE; teletext_descr_t *p_dr = NULL; subt_ttx_ctrl_priv_t *p_this = NULL; do { ERR_POINT(p_lang); p_this = get_priv(); ERR_POINT(p_this); memcpy(p_this->m_ttx_ctrl.m_ui_lang, p_lang, SUBT_TTX_CTRL_LANG_LEN); p_dr = _ttx_ctrl_match_dr(&p_this->m_ttx_ctrl, p_lang); // ERR_POINT(p_dr); OS_PRINTF("lubin: ttx_ctrl_start 863\n"); ret = _ttx_ctrl_start(&p_this->m_ttx_ctrl, p_dr); ERR_CHECK(ret); return ret; }while(0); return ERR_FAILURE; }
static RET_CODE rec_pin_pause_resume(handle_t _this, BOOL b_resume) { rec_pin_private_t *p_priv = get_priv(_this); u64 up = 0; u64 data_size = 0; u64 get_size = 0; u64 unit_size = p_priv->cfg.fill_unit_size; if (!b_resume) { return SUCCESS; } dmx_rec_get_data(p_priv->p_dmx_dev, p_priv->cfg.rec_in, &data_size); up = data_size - p_priv->obtain_data_len; get_size = up - up % unit_size; if (get_size > unit_size) { get_size -= unit_size; } else { get_size = 0; } p_priv->obtain_data_len += get_size; return SUCCESS; }
static RET_CODE fsrc_on_command(handle_t _this, icmd_t *p_cmd) { fsrc_filter_private_t *p_priv = get_priv(_this); fsrc_pin_t *p_pin = &p_priv->m_pin; switch (p_cmd->cmd) { case FSRC_CFG_FILE_NAME: if (p_cmd->p_para) { p_pin ->set_file_name(p_pin, (char *)p_cmd->p_para); } else if (p_cmd->lpara) { p_pin->set_buffer_read(p_pin, p_cmd->lpara); } break; case FSRC_CFG_SOURCE_PIN: p_pin->config(p_pin, (src_pin_attr_t *)p_cmd->p_para); break; default: return ERR_FAILURE; } return SUCCESS; }
static RET_CODE rec_pin_cfg_buffer(handle_t _this, void *p_para) { rec_pin_private_t *p_priv = get_priv(_this); rec_buf_cfg_t *p_cfg = (rec_buf_cfg_t *)p_para; if((p_cfg == NULL) || (p_cfg->p_rec_buffer == NULL) || (p_cfg->total_buf_len == 0)) { OS_PRINTF("error input para\n"); return ERR_FAILURE; } if((p_cfg->total_buf_len % p_cfg->atom_size) != 0) { OS_PRINTF("error atom size\n"); return ERR_FAILURE; } memcpy(&p_priv->cfg, p_cfg, sizeof(rec_buf_cfg_t)); CHECK_FAIL_RET_CODE(p_priv->cfg.fill_expect_size > 0); CHECK_FAIL_RET_CODE(p_priv->cfg.fill_unit_size > 0); return dmx_rec_chan_set_buffer(p_priv->p_dmx_dev, p_cfg->rec_in, p_cfg->p_rec_buffer, p_cfg->total_buf_len); }
/*! * If subtitle set on, it will be shown when UI plays program, but now pmt may not be parsed * So set p_subt->m_ui_enable as true, when pmt has been parsed, show subtitle */ static void _subt_ctrl_auto(void) { subt_ctrl_t *p_subt = NULL; subt_ttx_ctrl_priv_t *p_this = NULL; p_this = get_priv(); if(NULL == p_this) { return; } p_subt = &p_this->m_subt_ctrl; if(FALSE == p_subt->enable) { return; } if(p_subt->m_subt_start || p_subt->m_ttx_start) { return; } _subt_ctrl_get_type_and_lang(p_subt); if(((E_SUBT_TYPE_TTX_NORMAL == p_subt->wait_type) || (E_SUBT_TYPE_TTX_HEARING_HI == p_subt->wait_type)) && (NULL != p_subt->ttx_type_subt_cb)) { p_subt->ttx_type_subt_cb(0); } _subt_ctrl_show(p_subt->m_ui_lang, p_subt->wait_type); }
static void my_set_property (GObject *gobject, guint property_id, const GValue *value, GParamSpec *pspec) { GeglOperation *operation = GEGL_OPERATION (gobject); GeglProperties *o = GEGL_PROPERTIES (operation); Priv *p = get_priv(o); GObject *buffer = NULL; switch (property_id) { case PROP_buffer: if (o->buffer) { // Invariant: valid buffer should always have valid signal handler g_assert(p->buffer_changed_handler > 0); g_signal_handler_disconnect (o->buffer, p->buffer_changed_handler); /* XXX: should decrement signal connected count */ } buffer = G_OBJECT (g_value_get_object (value)); if (buffer) { p->buffer_changed_handler = gegl_buffer_signal_connect (GEGL_BUFFER(buffer), "changed", G_CALLBACK(buffer_changed), operation); } break; default: break; } /* The set_property provided by the chant system does the * storing and reffing/unreffing of the input properties */ set_property(gobject, property_id, value, pspec); }
static RET_CODE rec_pin_free_pid(handle_t _this, void *p_data) { rec_pin_private_t *p_priv = get_priv(_this); memset(p_priv->slot_arry, 0, sizeof(p_priv->slot_arry)); p_priv->used_num = 0; return SUCCESS; }
static void fsrc_pin_set_file_name(handle_t _this, char *p_file_name) { fsrc_pin_private_t *p_priv = get_priv(_this); MT_ASSERT(p_file_name != NULL); strncpy(p_priv->file_name, p_file_name, MAX_FILE_PATH); p_priv->buf_get = NULL; }
u32 subt_satation_out_get_showed_time(handle_t _this, u32 *p_start, u32 *p_end) { subt_station_out_pin_priv_t *p_priv = get_priv(_this); *p_start = p_priv->last_start; *p_end = p_priv->last_end; return SUCCESS; }
static RET_CODE subt_station_out_pin_on_start(handle_t _this) { subt_station_out_pin_priv_t *p_priv = get_priv(_this); memset(&p_priv->report, 0, sizeof(subt_station_out_report_t)); p_priv->p_out_buf = mtos_malloc(KBYTES); return SUCCESS; }
void subt_ttx_ctrl_reset(void) { subt_ttx_ctrl_priv_t *p_this = NULL; p_this = get_priv(); _subt_ctrl_reset(&p_this->m_subt_ctrl); _ttx_ctrl_reset(&p_this->m_ttx_ctrl); }
static void rec_pin_on_destroy(handle_t _this) { rec_pin_private_t *p_priv = get_priv(_this); if(p_priv != NULL) { mtos_free((void *)p_priv); } }
static RET_CODE subt_station_out_pin_on_stop(handle_t _this) { subt_station_out_pin_priv_t *p_priv = get_priv(_this); if(p_priv->p_out_buf != NULL) { mtos_free(p_priv->p_out_buf); p_priv->p_out_buf = NULL; } return SUCCESS; }
static void request_sample(handle_t _this, media_sample_t *p_sample) { media_format_t media_format = {MT_FILE_DATA}; mp3_trans_in_pin_private_t *p_priv = NULL; interface_t *p_interface = NULL; ipin_t *p_connecter = NULL; net_src_pin_request_t net_request = {0}; p_priv = get_priv(_this); CHECK_FAIL_RET_VOID(p_priv != NULL); p_interface = ((ipin_t *)_this)->get_connected(_this); CHECK_FAIL_RET_VOID(p_interface != NULL); p_connecter = (ipin_t *)p_interface; if(p_connecter->is_supported_format(p_connecter, &media_format)) { iasync_reader_t *p_reader = NULL; p_connecter->get_interface(p_connecter, IASYNC_READER_INTERFACE, (void **)&p_reader); if ((p_reader != NULL) && (p_sample->state != SAMP_STATE_INSUFFICIENT)) { #ifndef WIN32 p_reader->request(p_reader, &p_sample->format, SIZEREQ, 0, 0, NULL, 0); #else p_reader->request(p_reader, &p_sample->format, 6 * 1024, 0, 0, NULL, 0); #endif } } else { net_src_interface_t *p_net_src = NULL; void *p_data = p_sample->p_user_data; //for network music, this para is used for url addr. p_connecter->get_interface(p_connecter, NET_INTERFACE_NAME, (void **)&p_net_src); CHECK_FAIL_RET_VOID(p_net_src != NULL); if(p_net_src != NULL && p_data != NULL) { net_request.p_url = (char *)p_data; net_request.context = 1; net_request.is_once_get_all_data = 0; net_request.is_monitor = 0; net_request.p_post = NULL; p_net_src->i_request(p_connecter, &net_request); } } }
static void request_sample(handle_t _this, media_sample_t *p_sample) { s32 ret = -1; ipin_t *p_ipin = (ipin_t *)_this; lrc_in_pin_private_t *p_priv = get_priv(_this); iasync_reader_t *p_reader = p_priv->p_reader; if (!p_ipin->is_connected(p_ipin)) { return ; } ret = p_reader->request(p_reader, &p_sample->format, 4096, 0, 0, NULL, 0); }
static RET_CODE _on_open(handle_t _this) { mplayer_aud_filter_private_t *p_priv = get_priv(_this); ifilter_t *p_ifilter = (ifilter_t *)_this; p_priv->first_frame = TRUE; p_priv->lrc_play_time = 0; p_priv->cur_play_time = 0; p_priv->b_load_meida_success = 0; p_ifilter->set_active_enter(p_ifilter, _mplayer_aud_loop_time); return SUCCESS; }
static RET_CODE subt_station_out_decide_buffer_size(handle_t _this) { subt_station_out_pin_priv_t *p_priv = get_priv(_this); imem_allocator_t *p_alloc = p_priv->p_alloc; p_alloc->get_properties(p_alloc, &p_priv->properties); p_priv->properties.use_virtual_space = TRUE; p_priv->properties.buffers = 1; p_priv->properties.buffer_size = p_priv->buf_size; p_alloc->set_properties(p_alloc, &p_priv->properties, NULL); return SUCCESS; }
static RET_CODE decide_buffer_size(handle_t _this) { rec_out_pin_private_t *p_priv = get_priv(_this); imem_allocator_t *p_alloc = p_priv->p_alloc; allocator_properties_t properties; //config mem_alloc p_alloc->get_properties(p_alloc, &properties); properties.buffers = 2; properties.buffer_size = 5 * 188; p_alloc->set_properties(p_alloc, &properties, NULL); return SUCCESS; }