/*================================================================================================
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;
}
