/*
* Loads url and starts playback.
* On success returns 0, on failure -1.
*/
int
player_play(const char *url)
{
if (state != STOPPED)
player_stop();
if (openfile(url) < 0)
return -1;
if (openaudio() < 0) {
closefile();
return -1;
}
flinit(); /* initialize the framelist */
/*
* Create two threads: one for reading and decoding the url,
* the other one for cleaning up after the track has finished or
* after an abort signal.
*/
pthread_create(&decodetid, NULL, decodethread, NULL);
pthread_create(&watchtid, NULL, watchthread, NULL);
pthread_detach(watchtid);
SDL_PauseAudio(0); /* start playback (1 = Pause, 0 = Play) */
state = PLAYING;
return 0;
}
/* --------------------------------------------------------------------------*/
int player_exit(int pid)
{
int ret = PLAYER_SUCCESS;
play_para_t *para;
log_print("[player_exit:enter]pid=%d\n", pid);
para = player_open_pid_data(pid);
if (para != NULL) {
log_print("[player_exit]player_state=0x%x\n", get_player_state(para));
if (get_player_state(para) != PLAYER_EXIT) {
player_stop(pid);
}
ret = player_thread_wait_exit(para);
log_print("[player_exit]player thread already exit: %d\n", ret);
ffmpeg_uninterrupt(para->thread_mgt.pthread_id);
FREE(para);
para = NULL;
}
player_close_pid_data(pid);
player_release_pid(pid);
log_print("[player_exit:exit]pid=%d\n", pid);
return ret;
}
/*
* Class: com_farcore_playerservice_MediaPlayer
* Method: stop
* Signature: (I)I
*/
JNIEXPORT jint JNICALL Java_com_farcore_playerservice_AmPlayer_stop
(JNIEnv *env, jobject obj, jint pid){
int ret = -1;
LOGI("player stop");
ret =player_stop(pid);
return ret;
}
void player_pause(void)
{
if (ip && ip_is_remote(ip) && consumer_status == CS_PLAYING) {
/* pausing not allowed */
player_stop();
return;
}
player_lock();
if (consumer_status == CS_STOPPED) {
_producer_play();
if (producer_status == PS_PLAYING) {
_consumer_play();
if (consumer_status != CS_PLAYING)
_producer_stop();
}
_player_status_changed();
if (consumer_status == CS_PLAYING)
_prebuffer();
player_unlock();
return;
}
_producer_pause();
_consumer_pause();
_player_status_changed();
player_unlock();
}
static int player_close(MSFilter *f, void *arg){
PlayerData *d=(PlayerData*)f->data;
player_stop(f,NULL);
if (d->fd>=0) close(d->fd);
d->fd=-1;
d->state=CLOSED;
return 0;
}
static void Done(tta* p)
{
free(p->Buffer);
p->Buffer = NULL;
close_tta_file(&p->Decoder);
player_stop();
}
static void
tta_free (DB_fileinfo_t *_info) {
tta_info_t *info = (tta_info_t *)_info;
if (info) {
player_stop (&info->tta);
close_tta_file (&info->tta);
free (info);
}
}
void
player_exit(void)
{
if (state != STOPPED)
player_stop();
avformat_network_deinit();
SDL_Quit();
}
gboolean
player_set_file (Player *player,
const char *file,
char **error)
{
GstElementState new_state;
g_return_val_if_fail (IS_PLAYER (player), FALSE);
*error = NULL;
if (player->priv->eos_idle_id > 0) {
g_source_remove (player->priv->eos_idle_id);
player->priv->eos_idle_id = 0;
}
if (!file) {
player_stop (player);
return FALSE;
}
switch (gst_element_get_state (GST_ELEMENT (player->priv->play))) {
case GST_STATE_PLAYING:
new_state = GST_STATE_PLAYING;
player_stop (player);
break;
default:
new_state = GST_STATE_READY;
break;
}
g_free (player->priv->current_file);
player->priv->current_file = g_strdup (file);
gst_play_set_location (player->priv->play, file);
gst_element_set_state (GST_ELEMENT (player->priv->play), new_state);
player->priv->pos = 0;
return TRUE;
}
static void *rtsp_conversation_thread_func(void *pconn) {
// SIGUSR1 is used to interrupt this thread if blocked for read
sigset_t set;
sigemptyset(&set);
sigaddset(&set, SIGUSR1);
pthread_sigmask(SIG_UNBLOCK, &set, NULL);
rtsp_conn_info *conn = pconn;
rtsp_message *req, *resp;
char *hdr, *auth_nonce = NULL;
while ((req = rtsp_read_request(conn->fd))) {
resp = msg_init();
resp->respcode = 400;
apple_challenge(conn->fd, req, resp);
hdr = msg_get_header(req, "CSeq");
if (hdr)
msg_add_header(resp, "CSeq", hdr);
msg_add_header(resp, "Audio-Jack-Status", "connected; type=analog");
if (rtsp_auth(&auth_nonce, req, resp))
goto respond;
struct method_handler *mh;
for (mh=method_handlers; mh->method; mh++) {
if (!strcmp(mh->method, req->method)) {
mh->handler(conn, req, resp);
break;
}
}
respond:
msg_write_response(conn->fd, resp);
msg_free(req);
msg_free(resp);
}
debug(1, "closing RTSP connection\n");
if (conn->fd > 0)
close(conn->fd);
if (rtsp_playing()) {
rtp_shutdown();
debug(1, "stop player\n");
player_stop();
debug(1, "player stoped\n");
please_shutdown = 0;
pthread_mutex_unlock(&playing_mutex);
}
if (auth_nonce)
free(auth_nonce);
conn->running = 0;
debug(2, "terminating RTSP thread\n");
return NULL;
}
void rtsp_shutdown_stream(void) { // printf("enter %s\n",__FUNCTION__);
CloseAllSocket();
if (rtsp_playing())
{
rtp_shutdown();
player_stop();
please_shutdown = 1;
pthread_mutex_unlock(&playing_mutex);
}
}
static void
player_finalize (GObject *object)
{
Player *player = PLAYER (object);
player_stop (player);
g_free (player->priv);
if (G_OBJECT_CLASS (parent_class)->finalize)
(* G_OBJECT_CLASS (parent_class)->finalize) (object);
}
int
cmd_reload(int argc, char *argv[])
{
char *db_file;
char *playlist_dir;
if (argc != 2) {
paint_error("usage: %s [ db | conf ]", argv[0]);
return 1;
}
/* reload database or config file */
if (strcasecmp(argv[1], "db") == 0) {
db_file = strdup(mdb.db_file);
playlist_dir = strdup(mdb.playlist_dir);
if (db_file == NULL || playlist_dir == NULL)
err(1, "cmd_reload: strdup(3) failed");
/* stop playback TODO investigate a nice way around this */
player_stop();
/* reload db */
medialib_destroy();
medialib_load(db_file, playlist_dir);
/* sort entries */
qsort(mdb.library->files, mdb.library->nfiles, sizeof(meta_info*), mi_compare);
free(db_file);
free(playlist_dir);
/* re-setup ui basics */
playing_playlist = NULL;
setup_viewing_playlist(mdb.library);
ui.library->voffset = 0;
ui.library->nrows = mdb.nplaylists;
ui.library->crow = 0;
paint_all();
} else if (strcasecmp(argv[1], "conf") == 0) {
load_config();
paint_message("configuration reloaded");
} else {
paint_error("usage: %s [ db | conf ]", argv[0]);
return 2;
}
return 0;
}
static void* music_player_thread (thread_handler* h)
{
music_player* mp = (music_player*) h;
while(!h->cancel) {
int song;
if (0 > read (mp->control[0], &song, sizeof(song)))
break;
player_stop(mp);
if (song >= 0)
player_start(mp, mp->songs[song]);
}
return NULL;
}
/**
* 停止TTA音乐文件的播放，销毁所占有的线程、资源等
*
* @note 不可以在播放线程中调用，必须能够多次重复调用而不死机
*
* @return 成功时返回0
*/
static int tta_end(void)
{
__end();
xAudioEnd();
if (g_buff != NULL) {
free(g_buff);
g_buff = NULL;
}
player_stop();
close_tta_file(&ttainfo);
g_status = ST_STOPPED;
generic_end();
return 0;
}
static void
error_cb (GObject *object,
GstObject *origin,
char *error,
Player *player)
{
PlayerError *data = g_new0 (PlayerError, 1);
/* Stop playing so we don't get repeated error messages. Might lead to
* troubles with threads, not sure.
*/
player_stop (player);
data->player = player;
data->error = g_strdup (error);
g_idle_add ((GSourceFunc) error_idle_cb, data);
}
void aff_text(t_data *data, t_bunny_picture *text)
{
int i;
t_bunny_position pos;
pos.x = data->player.x - 100;
pos.y = data->player.y - 350;
i = 0;
while (i < 250)
{
aff_map(data);
player_stop(data);
(data->inv.open == 1 ? aff_inventory(data) : (void)0);
bunny_blit(&data->win->buffer, text, &pos);
bunny_display(data->win);
my_sleep(200);
i++;
}
}
void launch_turtle_end(t_data *data)
{
int nbr;
nbr = 0;
data->cupa_end = 1;
while (data->inv.turtle_pos.x != 1024)
{
data->inv.turtle_pos.x++;
(data->map.pos_calq1.y > (322 - 272) ? data->map.pos_calq1.y-- : 0);
(data->map.pos_calq2.y < (655 - 272) ? data->map.pos_calq2.y++ : 0);
if (nbr == 0)
{
player_stop(data);
aff_map(data);
(data->inv.open == 1 ? aff_inventory(data) : (void)0);
bunny_blit(wb, data->inv.item_min[0].item, &data->inv.turtle_pos);
bunny_blit(wb, data->map.calq1, &data->map.pos_calq1);
bunny_blit(wb, data->map.calq2, &data->map.pos_calq2);
bunny_display(data->win);
}
(nbr == 2 ? nbr = 0 : nbr++);
}
}
/*
* Non-blocking getchar
* Returns the character if one is available, else it returns -1.
*/
static int
nbgetchar(void)
{
struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
fd_set fds;
int nr;
FD_ZERO(&fds);
FD_SET(STDIN_FILENO, &fds);
select(STDIN_FILENO + 1, &fds, NULL, NULL, &tv);
if (FD_ISSET(STDIN_FILENO, &fds))
nr = getchar();
else
nr = -1;
return nr;
}
static void
play(const char *url, int cflag)
{
struct mix *mix = NULL;
char *playtoken;
int mixid;
settermios();
player_init();
playtoken = getplaytoken();
if (playtoken == NULL) {
printf("Could not get a playtoken\n");
goto end;
}
mix = mix_getbyurl(url);
if (mix == NULL) {
printf("Mix not found.\n");
goto end;
}
start:
printf("%s by %s\n", mix->name, mix->user);
playmix(mix->id, playtoken);
if (cflag && !quitflag) {
mixid = mix->id;
mix_free(mix);
mix = mix_getbysimilar(mixid, playtoken);
if (mix == NULL)
printf("Could not get the next mix.\n");
else
goto start;
}
end:
mix_free(mix);
free(playtoken);
player_exit();
resettermios();
}
static void
playmix(int mixid, const char *playtoken)
{
struct track *track;
int cmd, i;
track = track_getfirst(mixid, playtoken);
if (track == NULL) {
printf("Could not load the playlist.\n");
return;
}
for (i = 1; track != NULL; ++i) {
printf("%02d. %s - %s\n", i, track->performer, track->name);
cmd = playtrack(mixid, track, playtoken);
track_free(track);
if (quitflag)
break;
if (cmd == NEXT)
track = track_getnext(mixid, playtoken);
else if (cmd == SKIP)
track = track_getskip(mixid, playtoken);
else if (cmd == SKIPMIX)
break;
}
}
/*
* Playtrack plays the track and checks for user input. It returns a
* suggestion on what to do next. It can return NEXT to suggest that the track
* has finished without user interruption and it is ready for the next track,
* or it can return SKIP or SKIPMIX.
*/
static int
playtrack(int mixid, struct track *track, const char *playtoken)
{
struct timespec tm = { .tv_sec = 0, .tv_nsec = 50000000 };
int ch, cmd = NEXT, reportflag = 0;
player_play(track->url);
while (player_getstatus() != STOPPED) {
if (quitflag) {
player_stop();
goto end;
}
printtime();
ch = nbgetchar();
switch (ch) {
case 'q':
printf("Quitting...\n");
player_stop();
quitflag = 1;
goto end;
case '\n':
case '\r':
printf("Skipping...\n");
if (!track->skipallowedflag) {
printf("Skip not allowed.\n");
} else {
player_stop();
cmd = SKIP;
goto end;
}
break;
case '>':
printf("Skipping mix...\n");
player_stop();
cmd = SKIPMIX;
goto end;
case 'p':
case ' ':
player_togglepause();
break;
default:
break;
}
if (!reportflag && player_getposition() > 30) {
report(track->id, mixid, playtoken);
reportflag = 1;
}
nanosleep(&tm, NULL);
}
end:
return cmd;
}
static void
printshortmix(struct mix *mix)
{
printf("%s\n", mix->url + 1); /* skip first character */
printf("\t%s\n", mix->tags);
if (mix->certification != NULL)
printf("\tcert: %s\n", mix->certification);
if (mix->duration < 0) {
printf("\tplays: %d\tlikes: %d\t(%d tracks)\n",
mix->playscount, mix->likescount, mix->trackscount);
} else {
printf("\tplays: %d\t likes: %d\t%d min (%d tracks)\n",
mix->playscount, mix->likescount, mix->duration / 60,
mix->trackscount);
}
}
static void
query(const char *url)
{
struct mix *mix;
mix = mix_getbyurl(url);
if (mix == NULL) {
printf("Mix not found.\n");
goto end;
}
printf("Mix name:\t%s ", mix->name);
printf("(id: %d)\n", mix->id);
printf("Created by:\t%s ", mix->user);
printf("(id: %d)\n", mix->userid);
printf("Description:\n%s\n", mix->description);
printf("Tags:\t%s\n", mix->tags);
if (mix->certification)
printf("Certification:\t%s\n", mix->certification);
printf("Plays: %d\t likes: %d\t%d min (%d tracks)\n",
mix->playscount, mix->likescount, mix->duration / 60,
mix->trackscount);
end:
mix_free(mix);
}
static void
printtime(void)
{
int duration, position;
if (player_getstatus() == PAUSED) {
printf("(paused) \r");
} else {
duration = player_getduration();
position = player_getposition();
printf("%02d:%02d/%02d:%02d\r",
position / 60, position % 60,
duration / 60, duration % 60);
}
fflush(stdout);
}
static void
action_stop (AGlActor* button, gpointer _)
{
player_stop();
}
/* this is called for each file to process */
enum codec_status codec_run(void)
{
tta_info info;
unsigned int decodedsamples;
int endofstream;
int new_pos = 0;
int sample_count;
intptr_t param;
if (codec_init())
{
DEBUGF("codec_init() error\n");
return CODEC_ERROR;
}
ci->seek_buffer(0);
if (set_tta_info(&info) < 0 || player_init(&info) < 0)
return CODEC_ERROR;
codec_set_replaygain(ci->id3);
ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
if (info.NCH == 2) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
} else if (info.NCH == 1) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
} else {
DEBUGF("CODEC_ERROR: more than 2 channels\n");
player_stop();
return CODEC_ERROR;
}
/* The main decoder loop */
decodedsamples = 0;
endofstream = 0;
if (ci->id3->offset > 0)
{
/* Need to save offset for later use (cleared indirectly by advance_buffer) */
new_pos = set_position(ci->id3->offset, TTA_SEEK_POS);
if (new_pos >= 0)
decodedsamples = new_pos;
}
ci->set_elapsed((uint64_t)info.LENGTH * 1000 * decodedsamples / info.DATALENGTH);
while (!endofstream)
{
enum codec_command_action action = ci->get_command(¶m);
if (action == CODEC_ACTION_HALT)
break;
if (action == CODEC_ACTION_SEEK_TIME)
{
new_pos = set_position(param / SEEK_STEP, TTA_SEEK_TIME);
if (new_pos >= 0)
{
decodedsamples = new_pos;
}
ci->set_elapsed((uint64_t)info.LENGTH * 1000 * decodedsamples / info.DATALENGTH);
ci->seek_complete();
}
sample_count = get_samples(samples);
if (sample_count < 0)
break;
ci->pcmbuf_insert(samples, NULL, sample_count);
decodedsamples += sample_count;
if (decodedsamples >= info.DATALENGTH)
endofstream = 1;
ci->set_elapsed((uint64_t)info.LENGTH * 1000 * decodedsamples / info.DATALENGTH);
}
player_stop();
return CODEC_OK;
}
/* this is the codec entry point */
enum codec_status codec_main(void)
{
tta_info info;
int status;
unsigned int decodedsamples;
int endofstream;
int new_pos = 0;
int sample_count;
/* Generic codec initialisation */
ci->configure(DSP_SET_SAMPLE_DEPTH, TTA_OUTPUT_DEPTH - 1);
next_track:
status = CODEC_OK;
if (codec_init())
{
DEBUGF("codec_init() error\n");
status = CODEC_ERROR;
goto exit;
}
if (codec_wait_taginfo() != 0)
goto done;
if (set_tta_info(&info) < 0 || player_init(&info) < 0)
{
status = CODEC_ERROR;
goto exit;
}
codec_set_replaygain(ci->id3);
ci->configure(DSP_SWITCH_FREQUENCY, ci->id3->frequency);
if (info.NCH == 2) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_INTERLEAVED);
} else if (info.NCH == 1) {
ci->configure(DSP_SET_STEREO_MODE, STEREO_MONO);
} else {
DEBUGF("CODEC_ERROR: more than 2 channels\n");
status = CODEC_ERROR;
goto done;
}
/* The main decoder loop */
decodedsamples = 0;
endofstream = 0;
if (ci->id3->offset > 0)
{
/* Need to save offset for later use (cleared indirectly by advance_buffer) */
new_pos = set_position(ci->id3->offset, TTA_SEEK_POS);
if (new_pos >= 0)
decodedsamples = new_pos;
ci->seek_complete();
}
while (!endofstream)
{
ci->yield();
if (ci->stop_codec || ci->new_track)
break;
if (ci->seek_time)
{
new_pos = set_position(ci->seek_time / SEEK_STEP, TTA_SEEK_TIME);
if (new_pos >= 0)
{
decodedsamples = new_pos;
ci->seek_complete();
}
}
sample_count = get_samples(samples);
if (sample_count < 0)
{
status = CODEC_ERROR;
break;
}
ci->pcmbuf_insert(samples, NULL, sample_count);
decodedsamples += sample_count;
if (decodedsamples >= info.DATALENGTH)
endofstream = 1;
ci->set_elapsed((uint64_t)info.LENGTH * 1000 * decodedsamples / info.DATALENGTH);
}
done:
player_stop();
if (ci->request_next_track())
goto next_track;
exit:
return status;
}
static rt_bool_t home_view_event_handler(struct rtgui_widget* widget, struct rtgui_event* event)
{
if (event->type == RTGUI_EVENT_PAINT)
{
struct rtgui_dc* dc;
struct rtgui_rect rect;
rtgui_image_t *background;
/* draw child */
rtgui_view_event_handler(widget, event);
dc = rtgui_dc_begin_drawing(widget);
if (dc == RT_NULL) return RT_FALSE;
rtgui_widget_get_rect(widget, &rect);
/* draw background */
background = rtgui_image_create_from_file("hdc", "/resource/bg.hdc", RT_FALSE);
if (background != RT_NULL)
{
rtgui_image_blit(background, dc, &rect);
rtgui_image_destroy(background);
}
else
{
rtgui_dc_fill_rect(dc, &rect);
}
/* draw playing information */
player_update_tag_info();
rtgui_dc_end_drawing(dc);
return RT_FALSE;
}
else if (event->type == RTGUI_EVENT_KBD)
{
struct rtgui_event_kbd* ekbd = (struct rtgui_event_kbd*)event;
if (ekbd->type == RTGUI_KEYDOWN)
{
if ((ekbd->key == RTGUIK_LEFT) || (ekbd->key == RTGUIK_RIGHT))
{
if (player_mode == PLAYER_STOP)
{
rtgui_view_show(RTGUI_VIEW(function_view), RT_FALSE);
}
else
{
rt_device_t dev = rt_device_find("snd");
if (ekbd->key == RTGUIK_LEFT && radio_setup.default_volume > 0)
{
radio_setup.default_volume--;
rt_device_control(dev, CODEC_CMD_VOLUME, &radio_setup.default_volume);
}
else if (ekbd->key == RTGUIK_RIGHT && radio_setup.default_volume < CODEC_VOLUME_MAX)
{
radio_setup.default_volume++;
rt_device_control(dev, CODEC_CMD_VOLUME, &radio_setup.default_volume);
}
}
}
else
{
return RTGUI_WIDGET(music_listbox)->event_handler(RTGUI_WIDGET(music_listbox), event);
}
}
return RT_FALSE;
}
else if (event->type == RTGUI_EVENT_MOUSE_BUTTON)
{
struct rtgui_event_mouse* emouse;
emouse = (struct rtgui_event_mouse*)event;
if (emouse->button & RTGUI_MOUSE_BUTTON_UP)
{
if (rtgui_rect_contains_point(&next_btn_rect, emouse->x, emouse->y) == RT_EOK)
player_onbutton(NEXT_BUTTON);
else if (rtgui_rect_contains_point(&prev_btn_rect, emouse->x, emouse->y) == RT_EOK)
player_onbutton(PREV_BUTTON);
else if (rtgui_rect_contains_point(&playing_btn_rect, emouse->x, emouse->y) == RT_EOK)
player_onbutton(PLAYING_BUTTON);
}
}
else if (event->type == RTGUI_EVENT_COMMAND)
{
struct rtgui_event_command* ecmd = (struct rtgui_event_command*)event;
switch (ecmd->command_id)
{
case PLAYER_REQUEST_PLAY_SINGLE_FILE:
case PLAYER_REQUEST_PLAY_LIST:
rtgui_timer_start(info_timer);
return RT_TRUE;
case PLAYER_REQUEST_STOP:
{
struct play_item *item = RT_NULL;
/* if it's radio mode, set next mode to stop */
if (player_mode == PLAYER_PLAY_RADIO)
next_step = PLAYER_STEP_STOP;
/* set player mode */
player_mode = PLAYER_STOP;
switch (next_step)
{
case PLAYER_STEP_NEXT:
/* play next */
item = play_list_next(play_list_get_mode());
break;
case PLAYER_STEP_PREV:
/* play prev */
item = play_list_prev(play_list_get_mode());
break;
case PLAYER_STEP_SEEK:
/* play current item */
item = play_list_current();
}
if (item != RT_NULL)
player_play_item(item);
else
{
player_mode = PLAYER_STOP;
rtgui_timer_stop(info_timer);
}
/* update tag information */
player_update_tag_info();
}
return RT_TRUE;
case PLAYER_REQUEST_FREEZE:
{
/* stop play */
if (player_is_playing() == RT_TRUE)
{
player_stop();
}
/* delay some tick */
rt_thread_delay(50);
/* show a modal view */
{
rtgui_view_t *view;
rtgui_label_t *label;
rtgui_rect_t rect = {0, 0, 150, 150}, container_rect;
rtgui_graphic_driver_get_default_rect(&container_rect);
/* set centre */
rtgui_rect_moveto_align(&container_rect, &rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
view = rtgui_view_create("USB");
rtgui_workbench_add_view(workbench, view);
/* set container to window rect */
container_rect = rect;
rect.x1 = 0;
rect.y1 = 0;
rect.x2 = 120;
rect.y2 = 20;
label = rtgui_label_create("USB 联机中...");
rtgui_rect_moveto_align(&container_rect, &rect, RTGUI_ALIGN_CENTER_HORIZONTAL | RTGUI_ALIGN_CENTER_VERTICAL);
rtgui_widget_set_rect(RTGUI_WIDGET(label), &rect);
rtgui_container_add_child(RTGUI_CONTAINER(view), RTGUI_WIDGET(label));
rtgui_view_show(view, RT_TRUE);
/* never reach hear */
}
}
case PLAYER_REQUEST_UPDATE_INFO:
/* update status information */
player_update_tag_info();
return RT_TRUE;
default:
break;
}
return RT_FALSE;
}
return rtgui_view_event_handler(widget, event);
}
SoundPlayer::~SoundPlayer() {
player_stop();
pthread_mutex_destroy(&player_mutex);
pthread_mutex_destroy(&control_mutex);
}
int main(int argc,char *argv[])
{
play_control_t *pCtrl = NULL;
int pid;
int pos = 0;
int speed = 0;
int tmpneedexit = 0;
int ret = -1;
media_info_t minfo;
char tmpcommand[TMP_COMMAND_MAX];
EMU_STEP tmpstep = EMU_STEP_MENU;
pCtrl = (play_control_t*)malloc(sizeof(play_control_t));
memset(pCtrl,0,sizeof(play_control_t));
memset(&minfo,0,sizeof(media_info_t));
if(argc<2)
{
printf("usage:player file\n");
return -1;
}
player_init();
set_display_axis(0); //move osd out of screen to set video layer out
player_register_update_callback(&pCtrl->callback_fn,&update_player_info,1000);
printf("player callback register....\n");
pCtrl->file_name = strdup(argv[1]);
//pCtrl->nosound = 1; // if disable audio...,must call this api
pCtrl->video_index = -1;// MUST
pCtrl->audio_index = -1;// MUST
pCtrl->sub_index = -1;/// MUST
pCtrl->hassub = 1; // enable subtitle
//just open a buffer,just for p2p,http,etc...
//pCtrl->auto_buffing_enable = 1;
// pCtrl->buffing_min = 0.001;
// pCtrl->buffing_middle = 0.02;
// pCtrl->buffing_max = 0.9;
pCtrl->t_pos = -1; // start position, if live streaming, need set to -1
pCtrl->need_start = 0; // if 0,you can omit player_start_play API.just play video/audio immediately. if 1,need call "player_start_play" API;
pid=player_start(pCtrl,0);
if(pid<0)
{
printf("player start failed!error=%d\n",pid);
return -1;
}
signal(SIGSEGV, signal_handler);
//SYS_disable_osd0();
while((!tmpneedexit)&&(!PLAYER_THREAD_IS_STOPPED(player_get_state(pid)))){
switch (tmpstep) {
case EMU_STEP_PAUSE:
player_pause(pid);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_RESUME:
player_resume(pid);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_SEEK:
printf("will seek position:100\n");
pos = 100;
player_timesearch(pid,pos);
tmpstep = EMU_STEP_MENU;
break;
break;
case EMU_STEP_STOP:
player_stop(pid);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_FF:
printf("please input fastforward speed:\n");
speed = 1;
player_forward(pid,speed);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_RR:
printf("please input fastrewind speed:");
speed = 1;
player_backward(pid,speed);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_SETLOOP:
player_loop(pid);
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_EXIT:
player_exit(pid);
tmpneedexit = 1;
break;
case EMU_STEP_START:
player_start_play(pid);
//SYS_set_tsync_enable(0);///< f no sound,can set to be 0
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_GETAVMEDIAINFO:
if(pid>=0){
if(player_get_state(pid) > PLAYER_INITOK) {
ret = player_get_media_info(pid,&minfo);
if(ret==0)
_media_info_dump(&minfo);
}
}
tmpstep = EMU_STEP_MENU;
break;
case EMU_STEP_MENU:
do {
printf(SCREEN_SPLITER);
printf(" player benchmark tool for android v2.0\n");
printf(SCREEN_SPLITER);
printf("* Please choose one option *\r\n");
printf("* 0 show main menu *\r\n");
printf("* a start play *\r\n");
printf("* s get media info *\r\n");
printf("* 1 Pause play *\r\n");
printf("* 2 Resume play *\r\n");
printf("* 3 Stop play *\r\n");
printf("* 4 Fastforward *\r\n");
printf("* 5 Fastrewind *\r\n");
printf("* 6 Seek *\r\n");
printf("* 7 Set repeat *\r\n");
printf("* 8 Quit tools *\r\n");
printf(SCREEN_SPLITER);
printf("please input you choice:");
memset(tmpcommand,0,TMP_COMMAND_MAX);
scanf ("%s",tmpcommand);
if (strcmp(tmpcommand,"1")==0){
tmpstep = EMU_STEP_PAUSE;
}
if (strcmp(tmpcommand,"0")==0){
sleep(1);
tmpstep = EMU_STEP_MENU;
}
else if (strcmp(tmpcommand,"2")==0){
tmpstep = EMU_STEP_RESUME;
}
else if (strcmp(tmpcommand,"3")==0){
tmpstep = EMU_STEP_STOP;
}
else if (strcmp(tmpcommand,"4")==0){
tmpstep = EMU_STEP_FF;
}
else if (strcmp(tmpcommand,"5")==0){
tmpstep = EMU_STEP_RR;
}
else if (strcmp(tmpcommand,"6")==0) {
tmpstep = EMU_STEP_SEEK;
}
else if (strcmp(tmpcommand,"7")==0) {
tmpstep = EMU_STEP_SETLOOP;
}
else if (strcmp(tmpcommand,"8")==0) {
tmpstep = EMU_STEP_EXIT;
}
else if (strcmp(tmpcommand,"a")==0) {
tmpstep = EMU_STEP_START;
}
else if (strcmp(tmpcommand,"s")==0){
tmpstep = EMU_STEP_GETAVMEDIAINFO;
}
}while (0);
break;
}
usleep(100*1000);
signal(SIGCHLD, SIG_IGN);
signal(SIGTSTP, SIG_IGN);
signal(SIGTTOU, SIG_IGN);
signal(SIGTTIN, SIG_IGN);
signal(SIGHUP, signal_handler);
signal(SIGTERM, signal_handler);
signal(SIGSEGV, signal_handler);
signal(SIGINT, signal_handler);
signal(SIGQUIT, signal_handler);
}
set_display_axis(1); //recover osd
free(pCtrl->file_name);
free(pCtrl);
printf("...........player exit,~,byeybe...........\n");
return 0;
}
/* the menu logic for the ncurses interface, much simpler than it looks...
*/
void ninterface()
{
menu_parameters artists_menu, albums_menu, tracks_menu;
char *sections[] = {"Artists", "Albums", "Tracks" }; /* Section titles, used in the menu */
artist art;
album alb;
track song;
list np;
int art_choice, alb_choice, trak_choice;
/* ---===[ ARTISTS MENU ]===--- */
artists_menu = (menu_parameters)malloc(sizeof(struct menu_parameters_str));
artists_menu->list = get_artist_list();
artists_menu->list_len = num_artists;
artists_menu->title = "Artists:";
artists_menu->sections = sections;
artists_menu->num_sections = 3;
artists_menu->curr_section = 1;
artists_menu->commands = COMMANDS;
artists_menu->select = 0;
artists_menu->scroll = 0;
artists_menu->height = LINES;
artists_menu->width = COLS;
while(1) {
art_choice = nmenu(artists_menu); /* draw artist menu */
artists_menu->select = art_choice;
if(artists_menu->entered == QUIT_BACK) /* exit artist menu (and function) */
break;
else if(artists_menu->entered == APPEND_PLAYLIST || artists_menu->entered == REPLACE_PLAYLIST) { /* play an artist (XMMS2) */
if(artists_menu->entered == REPLACE_PLAYLIST) {
player_stop();
player_clear_playlist();
}
art = ((artist)(lookup(artists_menu->list[art_choice])->contents));
player_add_artist(art);
player_play();
} else if(artists_menu->entered == TOGGLE_PLAY_PAUSE) {
player_toggle();
} else if(artists_menu->entered == NOWPLAYING) {
now_playing();
} else if(artists_menu->entered == NEXT) {
player_next();
} else if(artists_menu->entered == PREVIOUS) {
player_previous();
}
/* ---===[ ALBUMS MENU ]===--- */
else if(artists_menu->entered == '\n') { /* enter this menu */
art = ((artist)(lookup(artists_menu->list[art_choice])->contents));
albums_menu = (menu_parameters)malloc(sizeof(struct menu_parameters_str));
albums_menu->list = get_album_list(art);
albums_menu->list_len = art->num_albums;
albums_menu->title = art->name;
albums_menu->sections = sections;
albums_menu->num_sections = 3;
albums_menu->curr_section = 2;
albums_menu->commands = COMMANDS;
albums_menu->select = 0;
albums_menu->scroll = 0;
albums_menu->height = LINES;
albums_menu->width = COLS;
while(1) {
alb_choice = nmenu(albums_menu); /* draw album menu */
if(albums_menu->entered == KEY_LEFT || albums_menu->entered == QUIT_BACK) /* exit albums menu */
break;
else if(albums_menu->entered == APPEND_PLAYLIST || albums_menu->entered == REPLACE_PLAYLIST) { /* play an album (XMMS2) */
if(albums_menu->entered == REPLACE_PLAYLIST) {
player_stop();
player_clear_playlist();
}
for(np = art->albums; np != NULL; np = np->next)
if(strcmp(albums_menu->list[alb_choice], np->name) == 0)
break;
alb = (album)np->contents;
player_add_album(alb);
player_play();
} else if(albums_menu->entered == TOGGLE_PLAY_PAUSE) {
player_toggle();
} else if(albums_menu->entered == NOWPLAYING) {
now_playing();
} else if(albums_menu->entered == NEXT) {
player_next();
} else if(albums_menu->entered == PREVIOUS) {
player_previous();
}
/* ---===[ TRACKS MENU ]===--- */
else if(albums_menu->entered == '\n') { /* enter this menu */
for(np = art->albums; np != NULL; np = np->next)
if(strcmp(albums_menu->list[alb_choice], np->name) == 0)
break;
alb = (album)np->contents;
tracks_menu = (menu_parameters)malloc(sizeof(struct menu_parameters_str));
tracks_menu->list = get_track_list(alb);
tracks_menu->list_len = alb->num_songs;
tracks_menu->title = alb->name;
tracks_menu->sections = sections;
tracks_menu->num_sections = 3;
tracks_menu->curr_section = 3;
tracks_menu->commands = COMMANDS;
tracks_menu->select = 0;
tracks_menu->scroll = 0;
tracks_menu->height = LINES;
tracks_menu->width = COLS;
while(1) {
trak_choice = nmenu(tracks_menu); /* draw track menu */
/* play a track (XMMS2) */
if(tracks_menu->entered == APPEND_PLAYLIST || tracks_menu->entered == REPLACE_PLAYLIST) { /* play a track (XMMS2) */
if(tracks_menu->entered == REPLACE_PLAYLIST) {
player_stop();
player_clear_playlist();
}
for(song = alb->songs; song != NULL; song = song->next)
if(strcmp(tracks_menu->list[trak_choice], song->name) == 0)
break;
player_add_track(song);
player_play();
} else if(tracks_menu->entered == TOGGLE_PLAY_PAUSE) {
player_toggle();
} else if(tracks_menu->entered == NOWPLAYING) {
now_playing();
} else if(tracks_menu->entered == KEY_LEFT || tracks_menu->entered == QUIT_BACK) { /* exit tracks menu */
break;
} else if(tracks_menu->entered == NEXT) {
player_next();
} else if(tracks_menu->entered == PREVIOUS) {
player_previous();
}
} /* drop out of tracks here */
destroy_menu_params(tracks_menu);
}
} /* drop out of albums here */
destroy_menu_params(albums_menu);
}
} /* drop out of artists here */
destroy_menu_params(artists_menu);
return;
}
void on_stop_activate(GtkAction * action, gpointer user_data)
{
player_stop(get_player(app));
}
JNIEXPORT jint JNICALL Java_com_chris_yanlong_PlayerView_player_1stop
(JNIEnv *env, jobject obj, jint handle ){
player_stop((int)handle);
}
static void function_filelist(struct rtgui_widget* widget, void* parameter)
{
rtgui_rect_t rect;
rtgui_filelist_view_t *view;
rtgui_widget_get_rect(RTGUI_WIDGET(workbench), &rect);
view = rtgui_filelist_view_create(workbench, "/SD", "*.*", &rect);
if (view != RT_NULL)
{
if (rtgui_view_show(RTGUI_VIEW(view), RT_TRUE) == RTGUI_MODAL_OK)
{
int type;
char fn[64];
/* get file */
rtgui_filelist_view_get_fullpath(view, fn, sizeof(fn));
type = media_type(fn);
/* stop playing */
player_stop();
/* check whether it's a folder */
if (is_directory(fn) == RT_TRUE)
{
play_list_append_directory(fn);
if (play_list_items() > 0)
{
player_play_item(play_list_start());
}
}
else if (type == MEDIA_WAV || type == MEDIA_MP3)
{
/* clear old play list */
play_list_clear();
/* append file */
play_list_append(fn);
player_play_item(play_list_start());
}
else if (type == MEDIA_M3U)
{
/* append m3u filelist */
play_list_append_m3u(fn);
if (play_list_items() > 0)
{
player_play_item(play_list_start());
}
}
player_update_list();
}
/* destroy view */
rtgui_filelist_view_destroy(view);
}
/* show home view */
rtgui_view_show(home_view, RT_FALSE);
return;
}
