static void net_route_named_msg(struct sk_buff *buf)
{
struct tipc_msg *msg = buf_msg(buf);
u32 dnode;
u32 dport;
if (!msg_named(msg)) {
msg_dbg(msg, "tipc_net->drop_nam:");
buf_discard(buf);
return;
}
dnode = addr_domain(msg_lookup_scope(msg));
dport = tipc_nametbl_translate(msg_nametype(msg), msg_nameinst(msg), &dnode);
dbg("tipc_net->lookup<%u,%u>-><%u,%x>\n",
msg_nametype(msg), msg_nameinst(msg), dport, dnode);
if (dport) {
msg_set_destnode(msg, dnode);
msg_set_destport(msg, dport);
tipc_net_route_msg(buf);
return;
}
msg_dbg(msg, "tipc_net->rej:NO NAME: ");
tipc_reject_msg(buf, TIPC_ERR_NO_NAME);
}
void tipc_net_route_msg(struct sk_buff *buf)
{
struct tipc_msg *msg;
u32 dnode;
if (!buf)
return;
msg = buf_msg(buf);
msg_incr_reroute_cnt(msg);
if (msg_reroute_cnt(msg) > 6) {
if (msg_errcode(msg)) {
msg_dbg(msg, "NET>DISC>:");
buf_discard(buf);
} else {
msg_dbg(msg, "NET>REJ>:");
tipc_reject_msg(buf, msg_destport(msg) ?
TIPC_ERR_NO_PORT : TIPC_ERR_NO_NAME);
}
return;
}
msg_dbg(msg, "tipc_net->rout: ");
/* Handle message for this node */
dnode = msg_short(msg) ? tipc_own_addr : msg_destnode(msg);
if (tipc_in_scope(dnode, tipc_own_addr)) {
if (msg_isdata(msg)) {
if (msg_mcast(msg))
tipc_port_recv_mcast(buf, NULL);
else if (msg_destport(msg))
tipc_port_recv_msg(buf);
else
net_route_named_msg(buf);
return;
}
switch (msg_user(msg)) {
case ROUTE_DISTRIBUTOR:
tipc_cltr_recv_routing_table(buf);
break;
case NAME_DISTRIBUTOR:
tipc_named_recv(buf);
break;
case CONN_MANAGER:
tipc_port_recv_proto_msg(buf);
break;
default:
msg_dbg(msg,"DROP/NET/<REC<");
buf_discard(buf);
}
return;
}
/* Handle message for another node */
msg_dbg(msg, "NET>SEND>: ");
tipc_link_send(buf, dnode, msg_link_selector(msg));
}
static void
as_card_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
UserPrefs *up = snd->ud->up;
SoundParams *sparams = snd->sparams;
char name[32] ;
char *p;
char *text;
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (widget));
app_free(sparams->indexstr);
app_free(sparams->device_name);
if ( ( p = strchr( text, ' ' )) ){
*p = 0;
}
sparams->indexstr = app_strdup(text);
if ( *text == '-' ){
sparams->device_name = app_strdup("default");
} else {
sprintf(name, "hw:%s", text );
sparams->device_name = app_strdup(name);
}
msg_dbg(_("card changed: idex = %s device = %s"), sparams->indexstr, sparams->device_name );
app_free(up->cardidstr);
up->cardidstr = app_strdup(sparams->indexstr);
as_setup_rate_combo( snd );
as_setup_format_combo(snd);
}
int ramdisk_ioctl (struct block_device *bdev,
fmode_t mode,
unsigned int cmd, unsigned long arg)
{
long size;
struct hd_geometry geo;
struct ramdisk_dev *dev = bdev->bd_disk->private_data;
msg_dbg("ramdisk: ioctl()\n");
switch(cmd) {
case HDIO_GETGEO:
/*
* Get geometry: since we are a virtual device, we have to make
* up something plausible. So we claim 16 sectors, four heads,
* and calculate the corresponding number of cylinders. We set the
* start of data at sector four.
*/
size = dev->size*(HARDSECT_SIZE/KERNEL_SECTOR_SIZE);
geo.cylinders = (size & ~0x3f) >> 6;
geo.heads = 4;
geo.sectors = 16;
geo.start = 4;
if (copy_to_user((void __user *) arg, &geo, sizeof(geo)))
return -EFAULT;
return 0;
}
return -ENOTTY; /* unknown command */
}
/*
* Look for a (simulated) media change.
*/
int ramdisk_media_changed(struct gendisk *gd)
{
struct ramdisk_dev *dev = gd->private_data;
msg_dbg("ramdisk: media_changed()\n");
return dev->media_change;
}
static int fvp_ad_codec_init()
{
msg_dbg("Fun[%s]\n", __func__);
ADCodec *ad_codec = ad_codec_create();
fvp_set_ad_codec(ad_codec);
return 0;
}
static int fvp_audio_output_device_init(AUDIO_DEV ao_output_dev_id)
{
msg_dbg("Fun[%s]\n", __func__);
AudioOutputDevice *audio_output_device = audio_output_device_create(ao_output_dev_id, 0);
fvp_set_audio_output_device(audio_output_device);
return 0;
}
int mpp_system_init(void)
{
HI_S32 s32Ret;
MPP_SYS_CONF_S stSysConf = {0};
VB_CONF_S stVbConf ={0};
static int mpp_inited = 0;
if(mpp_inited == 1)
{
msg_dbg("Mpp system have inited!\n");
return 0;
}
HI_MPI_SYS_Exit();
HI_MPI_VB_Exit();
// stVbConf.u32MaxPoolCnt = 128;
stVbConf.astCommPool[0].u32BlkSize = 720 * 576 * 4;
stVbConf.astCommPool[0].u32BlkCnt = 20;
s32Ret = HI_MPI_VB_SetConf(&stVbConf);
if (HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VB_SetConf failed 0x%x!\n",s32Ret);
return -1;
}
s32Ret = HI_MPI_VB_Init();
if(HI_SUCCESS != s32Ret)
{
printf("HI_MPI_VB_Init failed 0x%x!\n",s32Ret);
return -1;
}
stSysConf.u32AlignWidth = 16;
s32Ret = HI_MPI_SYS_SetConf(&stSysConf);
if (HI_SUCCESS != s32Ret)
{
HI_MPI_VB_Exit();
printf("conf : system config failed 0x%x!\n",s32Ret);
return -1;
}
s32Ret = HI_MPI_SYS_Init();
if(HI_SUCCESS != s32Ret)
{
HI_MPI_VB_Exit();
printf("HI_MPI_SYS_Init err 0x%x\n",s32Ret);
return -1;
}
mpp_inited = 1;
return 0;
}
/*
* Revalidate. WE DO NOT TAKE THE LOCK HERE, for fear of deadlocking
* with open. That needs to be reevaluated.
*/
int ramdisk_revalidate(struct gendisk *gd)
{
struct ramdisk_dev *dev = gd->private_data;
msg_dbg("ramdisk: revalidate()\n");
if (dev->media_change) {
dev->media_change = 0;
memset (dev->data, 0, dev->size);
}
return 0;
}
/*
* row is read in temp storage ss->rowData because
* we do not known if we have multiple set in the file
* indicated by a decreseing order of iv
*/
int sound_read_rows( AppClass *sss )
{
SoundStream *snd = (SoundStream *) sss;
int ret;
int row = 0;
while ((ret = sound_readrow(snd)) > 0) {
row++;
}
msg_dbg("Read %d rows %d", row, snd->nrows );
return ret;
}
static void
as_format_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
UserPrefs *up = snd->ud->up;
AsFormatList *p = as_format_list;
gint i = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
snd->sparams->format = (p + i)->format;
msg_dbg(_("format changed: text = %s, val = %d"), (p + i)->name, snd->sparams->format );
up->pcm_format = snd->sparams->format;
}
Access *access_avi_create(char *access_path)
{
return_val_if_fail(access_path, NULL);
int fd = -1;
char file_path[64] = {0};
if(avi_parse_path(access_path, file_path, 64) != 0)
{
msg_dbg("Fun(%s) error parse the access_path(%s) failed!\n", __func__, access_path);
return NULL;
}
Access *thiz = (Access *)FTK_ZALLOC(sizeof(Access) + sizeof(PrivInfo));
return_val_if_fail(thiz != NULL, NULL);
/*open the file */
fd = open(file_path, O_RDONLY);
if(fd <= 0)
{
msg_dbg("error:open the file failed! file path(%s)\n", file_path);
return NULL;
}
thiz->seek = NULL;
thiz->read = NULL;
thiz->block = access_avi_block;
thiz->control = NULL;
thiz->destroy = access_avi_destroy;
DECL_PRIV(thiz, priv);
priv->file_path = FTK_STRDUP(file_path);
priv->block = block_create(MAX_H264_PACKET_LEN);
access_init_ffmpeg(thiz, file_path);
return thiz;
}
static void ramdisk_invalidate(unsigned long ldev)
{
struct ramdisk_dev *dev = (struct ramdisk_dev *) ldev;
msg_dbg("ramdisk: invalidate()\n");
spin_lock(&dev->lock);
if (dev->users || !dev->data)
printk (KERN_WARNING "ramdisk: timer sanity check failed\n");
else
dev->media_change = 1;
spin_unlock(&dev->lock);
}
int ad_codec_config_audio_rate(ADCodec *thiz, AUDIO_SAMPLE_RATE_E audio_sample_rate)
{
return_val_if_failed(thiz != NULL && thiz->ad_fd >= 0, -1);
tw2865_audio_samplerate samplerate;
switch(audio_sample_rate)
{
case AUDIO_SAMPLE_RATE_8000:
samplerate = TW2865_SAMPLE_RATE_8000;
break;
case AUDIO_SAMPLE_RATE_16000:
samplerate = TW2865_SAMPLE_RATE_16000;
break;
case AUDIO_SAMPLE_RATE_32000:
samplerate = TW2865_SAMPLE_RATE_32000;
break;
case AUDIO_SAMPLE_RATE_44100:
samplerate = TW2865_SAMPLE_RATE_44100;
break;
case TW2865_SAMPLE_RATE_48000:
samplerate = TW2865_SAMPLE_RATE_48000;
break;
default:
msg_dbg("Error : Not support enSample:%d\n",audio_sample_rate);
return -1;
break;
}
if (ioctl(thiz->ad_fd, TW2865_SET_SAMPLE_RATE, &samplerate))
{
msg_dbg("ioctl TW2865_SET_SAMPLE_RATE err !!! \n");
close(thiz->ad_fd);
return -1;
}
return 0;
}
static void
as_input_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
UserPrefs *up = snd->ud->up;
SoundParams *sparams = snd->sparams;
char *text;
sparams->input = gtk_combo_box_get_active (GTK_COMBO_BOX (widget));
text = gtk_combo_box_text_get_active_text (GTK_COMBO_BOX_TEXT (widget));
sound_mixer_set( sparams->device_name, sparams->control_name, text);
msg_dbg(_("input changed: text = '%s', control = '%s', val = %d"), text, sparams->control_name, sparams->input );
up->input = sparams->input;
}
static int ramdisk_open(struct block_device *bdev, fmode_t mode)
{
struct ramdisk_dev *dev = bdev->bd_disk->private_data;
msg_dbg("ramdisk: open()\n");
del_timer_sync(&dev->timer);
spin_lock(&dev->lock);
if (! dev->users)
check_disk_change(bdev);
dev->users++;
spin_unlock(&dev->lock);
return 0;
}
static int fvp_windows_init(FvpConfigPara *config_para)
{
msg_dbg("fvp_windows_init\n");
// VideoWindows *hd_windows = video_windows_create(VO_DEV_HD, config_para->hd_dev_resolution, 1);
// fvp_set_hd_windows(hd_windows);
// VideoWindows *ad_windows = video_windows_create(VO_DEV_AD, config_para->ad_dev_resolution, 1);
// fvp_set_ad_windows(ad_windows);
VideoWindows *sd_windows = video_windows_create(VO_DEV_SD, config_para->sd_dev_resolution, 1);
fvp_set_sd_windows(sd_windows);
return 0;
}
static int drv_probe(struct msg_device* dev)
{
msg_dbg("DRIVER PROBING DEVICE\n");
chn.state = MSG_CHN_UNCONNECTED;
chn.port = &dev->interfaces[0].ports[0];
chn.dev = dev;
chn.connected = drv_chn_connected;
chn.receive = drv_chn_receive;
chn.closed = drv_chn_closed;
msg_connect_channel(&chn);
// set_capacity(ramdev.gd, NSECTORS*(HARDSECT_SIZE/KERNEL_SECTOR_SIZE));
return 0;
}
static void ramdisk_release(struct gendisk *disk, fmode_t mode)
{
struct ramdisk_dev *dev = disk->private_data;
msg_dbg("ramdisk: release()\n");
spin_lock(&dev->lock);
dev->users--;
if (!dev->users) {
dev->timer.expires = jiffies + INVALIDATE_DELAY;
add_timer(&dev->timer);
}
spin_unlock(&dev->lock);
}
static void
as_duration_entry_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
UserPrefs *up = snd->ud->up;
char text[64];
double val = g_strtod (gtk_entry_get_text (GTK_ENTRY (widget)), NULL );
if ( val != snd->sparams->duration ) {
snd->sparams->duration = val;
snd->sparams->numsamples = (unsigned int) val * snd->sparams->rate;
sprintf( text, "%u", snd->sparams->numsamples );
gtk_entry_set_text (GTK_ENTRY (snd->w_size), text);
msg_dbg(_("duration changed: text = '%s', val = %0.2f"), text, val );
up->duration = val;
}
}
ADCodec *ad_codec_create(void)
{
ADCodec *thiz = NULL;
int fd = -1;
fd = open(DEFAULT_AD_DEV_FILENAME, O_RDWR);
if(fd < 0)
{
msg_dbg("Fun[%s] error :open ad file failed!\n", __func__);
return NULL;
}
thiz = (ADCodec *)COMM_ALLOC(sizeof(ADCodec));
thiz->ad_fd = fd;
return thiz;
}
static void
as_rate_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
UserPrefs *up = snd->ud->up;
const gchar *text;
GtkWidget *entry = gtk_bin_get_child (GTK_BIN (widget));
text = gtk_entry_get_text (GTK_ENTRY (entry));
snd->sparams->rate = (unsigned int ) g_ascii_strtoull ( text, NULL, 10 );
if ( snd->w_size ){
g_signal_emit_by_name(snd->w_size, "changed");
}
msg_dbg(_("rate changed: text = %s, val = %d"), text, snd->sparams->rate );
up->rate = snd->sparams->rate;
}
static void
as_size_entry_changed_cb (GtkWidget *widget, gpointer pdata)
{
GawSndData *snd = (GawSndData *) pdata;
char text[64];
unsigned int val = (unsigned int) g_ascii_strtoull ( gtk_entry_get_text (GTK_ENTRY (widget)), NULL, 10 );
if ( val == snd->sparams->numsamples ) {
val = (unsigned int) snd->sparams->duration * snd->sparams->rate;
if ( val != snd->sparams->numsamples ) {
snd->sparams->numsamples = val;
sprintf( text, "%u", val );
gtk_entry_set_text (GTK_ENTRY (snd->w_size), text);
}
} else { /* input in this entry */
snd->sparams->numsamples = val;
sprintf( text, "%0.2f", (double) snd->sparams->numsamples / snd->sparams->rate );
gtk_entry_set_text (GTK_ENTRY (snd->w_duration), text);
}
msg_dbg(_("size changed: text = '%s', val = %0.2f"), text, val );
}
static void ramdisk_request(struct request_queue *q)
{
struct request *req;
int ret;
req = blk_fetch_request(q);
while (req) {
struct ramdisk_dev *dev = req->rq_disk->private_data;
if (req->cmd_type != REQ_TYPE_FS) {
printk (KERN_NOTICE "Skip non-fs request\n");
ret = -EIO;
goto done;
}
msg_dbg (KERN_NOTICE "Req dev %u dir %d sec %ld, nr %d\n",
(unsigned int)dev, rq_data_dir(req),
(long int)blk_rq_pos(req), blk_rq_cur_sectors(req));
ramdisk_transfer(dev, req);
ret = 0;
done:
req = blk_fetch_request(q);
}
}
static Block *access_avi_block(Access *thiz)
{
return_val_if_fail(thiz != NULL, NULL);
DECL_PRIV(thiz, priv);
AVPacket packet;
if(av_read_frame(priv->format_ctx, &packet)>=0)
{
if(packet.stream_index == priv->video_stream_index)
{
memcpy(priv->block->p_buffer, packet.data, packet.size);
priv->block->buffer_len = packet.size;
priv->block->frame_flag = VIDEO_FRAME_FLAG;
// priv->block->pts = packet.pts;
av_free_packet(&packet);
return priv->block;
}
else if(packet.stream_index == priv->audio_stream_index)
{
memcpy(priv->block->p_buffer, packet.data, packet.size);
priv->block->buffer_len = packet.size;
priv->block->frame_flag = AUDIO_FRAME_FLAG;
// priv->block->pts = packet.pts;
av_free_packet(&packet);
return priv->block;
}
else
{
printf("not define this stream!\n");
}
}
msg_dbg("access_avi_block error:return null !\n");
return NULL;
}
static void drv_sent(struct msg_buffer* buff)
{
msg_dbg("ramdisk_drv: sent\n");
kfree(buff);
}
static void drv_chn_closed(struct msg_channel* chn)
{
msg_dbg("ramdisk_drv: connected\n");
}
static void drv_chn_connected(struct msg_channel* chn)
{
msg_dbg("ramdisk_drv: connected\n");
setup_blk_device(&ramdev);
}
void as_sound_win_create(GawSndData *snd)
{
UserData *ud = snd->ud;
SoundParams *sparams = snd->sparams;
GtkWidget *dialog;
GtkWidget *vbox;
gint response;
GtkWidget *frame;
GtkWidget *combo;
GtkWidget *c_table;
GtkWidget *s_table;
GtkWidget *label;
GtkWidget *entry;
gchar *str;
char text[64];
dialog = gtk_dialog_new_with_buttons (_("Sound card settings and Capture"),
GTK_WINDOW (ud->window),
GTK_DIALOG_MODAL | GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Cancel"),
GTK_RESPONSE_REJECT,
_("_OK"),
GTK_RESPONSE_ACCEPT,
NULL);
vbox = gtk_dialog_get_content_area (GTK_DIALOG (dialog));
gtk_container_set_border_width (GTK_CONTAINER (vbox), 8);
/* frame Sound card setting */
frame = gtk_frame_new (_(" Sound card setting"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
c_table = gtk_grid_new ();
gtk_grid_set_column_spacing( GTK_GRID(c_table), 5);
gtk_grid_set_row_spacing( GTK_GRID (c_table), 2);
gtk_container_add (GTK_CONTAINER (frame), c_table);
/* title */
str = _("Card");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(c_table), label,
/* left, top, width, height */
0, 0, 1, 1 );
str = _("Input");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(c_table), label,
/* left, top, width, height */
1, 0, 1, 1 );
/* Card */
combo = gtk_combo_box_text_new ();
snd->w_card = combo;
as_setup_card_combo (combo, sparams);
g_signal_connect (combo, "changed",
G_CALLBACK (as_card_changed_cb),
( gpointer) snd );
gtk_grid_attach(GTK_GRID(c_table), combo,
/* left, top, width, height */
0, 1, 1, 1 );
/* Input */
combo = gtk_combo_box_text_new ();
as_setup_input_combo (combo, sparams);
g_signal_connect (combo, "changed",
G_CALLBACK (as_input_changed_cb),
( gpointer) snd );
gtk_grid_attach(GTK_GRID(c_table), combo,
/* left, top, width, height */
1, 1, 1, 1 );
/* title */
str = _("Sample Rate");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(c_table), label,
/* left, top, width, height */
0, 2, 1, 1 );
str = _("Sample Format");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(c_table), label,
/* left, top, width, height */
1, 2, 1, 1 );
/* rate */
combo = gtk_combo_box_text_new_with_entry ();
snd->w_rate = combo;
entry = gtk_bin_get_child (GTK_BIN (combo));
gtk_entry_set_alignment (GTK_ENTRY (entry), 1); /* right */
// as_setup_rate_combo (snd);
g_signal_connect (combo, "changed", G_CALLBACK (as_rate_changed_cb),
(gpointer) snd );
gtk_grid_attach(GTK_GRID(c_table), combo,
/* left, top, width, height */
0, 3, 1, 1 );
sprintf(text, "%d", sparams->rate);
gtk_entry_set_text (GTK_ENTRY (entry), text );
/* format */
combo = gtk_combo_box_text_new ();
snd->w_format = combo;
// as_setup_format_combo (snd);
g_signal_connect (combo, "changed",
G_CALLBACK (as_format_changed_cb),
( gpointer) snd );
gtk_grid_attach(GTK_GRID(c_table), combo,
/* left, top, width, height */
1, 3, 1, 1 );
/* fire the card setting callback */
int idx = 0;
if ( *sparams->indexstr != '-' ){
idx = 1 + atoi(sparams->indexstr);
}
gtk_combo_box_set_active (GTK_COMBO_BOX (snd->w_card), idx );
/* frame Capture Settings */
frame = gtk_frame_new (_(" Capture Settings"));
gtk_box_pack_start (GTK_BOX (vbox), frame, FALSE, TRUE, 0);
s_table = gtk_grid_new ();
gtk_grid_set_column_spacing( GTK_GRID(s_table), 5);
gtk_grid_set_row_spacing( GTK_GRID (s_table), 2);
gtk_container_add (GTK_CONTAINER (frame), s_table);
str = _("Duration : Seconds");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(s_table), label,
/* left, top, width, height */
0, 0, 1, 1 );
str = _("Sample number");
label = gtk_label_new( str );
gtk_grid_attach(GTK_GRID(s_table), label,
/* left, top, width, height */
1, 0, 1, 1 );
/* Size */
entry = gtk_entry_new() ;
snd->w_size = entry;
gtk_entry_set_alignment (GTK_ENTRY (entry), 1); /* right */
g_signal_connect (entry, "changed",
G_CALLBACK (as_size_entry_changed_cb),
( gpointer) snd );
gtk_grid_attach(GTK_GRID(s_table), entry,
/* left, top, width, height */
1, 1, 1, 1 );
/* Duration */
entry = gtk_entry_new() ;
snd->w_duration = entry;
gtk_entry_set_alignment (GTK_ENTRY (entry), 1); /* right */
g_signal_connect (entry, "changed",
G_CALLBACK (as_duration_entry_changed_cb),
( gpointer) snd);
gtk_grid_attach(GTK_GRID(s_table), entry,
/* left, top, width, height */
0, 1, 1, 1 );
sprintf(text, "%0.2f", sparams->duration);
sparams->duration -= 1.0;
gtk_entry_set_text (GTK_ENTRY (entry), text);
gtk_widget_show_all (vbox);
response = gtk_dialog_run (GTK_DIALOG (dialog));
if (response == GTK_RESPONSE_ACCEPT) {
msg_dbg(_("dialog OK loading fom sound card"));
DataFile *wdata = datafile_new( ud, "SoundCard" );
datafile_set_sound(wdata, sparams);
ap_load_wave ( wdata );
}
gtk_widget_destroy (dialog);
/*
* widget are suppressed
* need this for next creation
*/
snd->w_card = 0;
snd->w_rate = 0;
snd->n_rate = 0;
snd->w_format = 0;
snd->n_format = 0;
snd->w_duration = 0;
snd->w_size = 0;
}
static void drv_disconnect(struct msg_device* dev)
{
msg_dbg("DRIVER DISCONNECTED FROM DEVICE\n");
msg_close_channel(&chn);
}