| /* |
| * Copyright (C) 2014-2015 Freescale Semiconductor, Inc. All rights reserved. |
| * |
| */ |
| |
| /* |
| * This library is free software; you can redistribute it and/or |
| * modify it under the terms of the GNU Library General Public |
| * License as published by the Free Software Foundation; either |
| * version 2 of the License, or (at your pconfigion) any later version. |
| * |
| * This library is distributed in the hope that it will be useful, |
| * but WITHOUT ANY WARRANTY; without even the implied warranty of |
| * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| * Library General Public License for more details. |
| * |
| * You should have received a copy of the GNU Library General Public |
| * License along with this library; if not, write to the |
| * Free Software Foundation, Inc., 59 Temple Place - Suite 330, |
| * Boston, MA 02111-1307, USA. |
| */ |
| |
| /* |
| * Description: New gplay application use new playengine |
| * Author: Haihua Hu |
| * Create Data: 2015/06/24 |
| * Modify By: Haihua Hu |
| * Modify Data: 2015/08/03 |
| * Change log: |
| */ |
| |
| |
| #include <termio.h> |
| #include <unistd.h> |
| #include <pthread.h> |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include <signal.h> |
| #include <unistd.h> |
| #include <errno.h> |
| |
| |
| #include "playengine.h" |
| #include "playlist.h" |
| |
| |
| /* version information of gplay */ |
| #define FSL_PLAYENGINE_VERSION "FSL_GPLAY_01.00" |
| #define OS_NAME "_LINUX" |
| #define SEPARATOR " " |
| #define FSL_PLAYENGINE_VERSION_STR \ |
| (FSL_PLAYENGINE_VERSION OS_NAME SEPARATOR "build on" \ |
| SEPARATOR __DATE__ SEPARATOR __TIME__) |
| |
| typedef enum{ |
| PLAYER_REPEAT_NONE = 0, |
| PLAYER_REPEAT_PLAYLIST = 1, |
| PLAYER_REPEAT_CURRENT = 2, |
| } repeat_mode; |
| |
| typedef struct{ |
| |
| gchar *video_sink_name; |
| gchar *audio_sink_name; |
| gchar *text_sink_name; |
| gchar *suburi; |
| |
| PlayListHandle pl; |
| const gchar *current; |
| |
| repeat_mode repeat; |
| gint play_times; |
| gint timeout; |
| gint display_refresh_frq; |
| gboolean no_auto_next; |
| gboolean handle_buffering; |
| |
| }gplay_pconfigions; |
| |
| /* used by display thread and event callback */ |
| typedef struct{ |
| PlayEngine *engine; |
| gplay_pconfigions *options; |
| }CustomData; |
| |
| static volatile gboolean gexit_main = FALSE; |
| static volatile gboolean gexit_display_thread = FALSE; |
| static volatile gboolean gDisable_display = FALSE; |
| |
| |
| void |
| alarm_signal(int signum) |
| { |
| } |
| |
| void |
| set_alarm(guint seconds) |
| { |
| struct sigaction act; |
| /* Register alarm handler for alarm */ |
| act.sa_handler = &alarm_signal; |
| act.sa_flags = 0; |
| sigemptyset(&act.sa_mask); |
| sigaction(SIGALRM, &act, NULL); |
| /* Set timer for seconds */ |
| alarm(seconds); |
| } |
| |
| PlayEngineResult |
| playlist_next(PlayEngine *engine, |
| gplay_pconfigions *options) |
| { |
| if(options->repeat > PLAYER_REPEAT_CURRENT || options->repeat < PLAYER_REPEAT_NONE) |
| { |
| g_print("Unknown repeat mode\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| |
| switch( options->repeat ) |
| { |
| case PLAYER_REPEAT_NONE: |
| { |
| options->current = getNextItem(options->pl); |
| if(options->current) |
| { |
| g_print("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| else |
| { |
| gboolean islast = FALSE; |
| isLastItem(options->pl, &islast); |
| if(islast) |
| { |
| g_print("No more media file, exit gplay!\n"); |
| }else |
| { |
| g_print("playlist unknown error\n"); |
| } |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| break; |
| |
| case PLAYER_REPEAT_PLAYLIST: |
| { |
| options->current = getNextItem(options->pl); |
| if(options->current) |
| { |
| printf("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| else |
| { |
| gboolean islast = FALSE; |
| isLastItem(options->pl, &islast); |
| if(islast) |
| { |
| if (options->play_times>0){ |
| options->play_times--; |
| if (options->play_times == 0) { |
| g_print("Repeat mode finished\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| options->current = getFirstItem(options->pl); |
| if(options->current) |
| { |
| printf("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| }else |
| { |
| g_print("playlist unknown error\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| } |
| break; |
| |
| case PLAYER_REPEAT_CURRENT: |
| { |
| engine->play((PlayEngineHandle)engine); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| return PLAYENGINE_SUCCESS; |
| } |
| |
| PlayEngineResult |
| playlist_previous(PlayEngine *engine, |
| gplay_pconfigions * options) |
| { |
| gchar iName[1024]; |
| if(options->repeat > PLAYER_REPEAT_CURRENT || options->repeat < PLAYER_REPEAT_NONE) |
| { |
| g_print("Unknown repeat mode\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| |
| switch( options->repeat ) |
| { |
| case PLAYER_REPEAT_NONE: |
| { |
| options->current = getPrevItem(options->pl); |
| if(options->current) |
| { |
| g_print("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| else |
| { |
| gboolean isFirst = FALSE; |
| isFirstItem(options->pl, &isFirst); |
| if(isFirst) |
| { |
| g_print("No more media file, exit gplay!\n"); |
| }else |
| { |
| g_print("playlist unknown error\n"); |
| } |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| break; |
| |
| case PLAYER_REPEAT_PLAYLIST: |
| { |
| options->current = getPrevItem(options->pl); |
| if(options->current) |
| { |
| printf("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| else |
| { |
| gboolean isFirst = FALSE; |
| isFirstItem(options->pl, &isFirst); |
| if(isFirst) |
| { |
| if (options->play_times>0){ |
| options->play_times--; |
| if (options->play_times == 0) { |
| g_print("Repeat mode finished\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| |
| options->current = getLastItem(options->pl); |
| if(options->current) |
| { |
| printf("Now Playing: %s\n", options->current); |
| engine->set_file((PlayEngineHandle)engine, options->current); |
| engine->play((PlayEngineHandle)engine); |
| } |
| }else |
| { |
| g_print("playlist unknown error\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| } |
| } |
| break; |
| |
| case PLAYER_REPEAT_CURRENT: |
| { |
| engine->play((PlayEngineHandle)engine); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| return PLAYENGINE_SUCCESS; |
| } |
| |
| |
| void |
| event_callback(void *context, |
| EventType EventID, |
| void *Eventpayload) |
| { |
| CustomData * PlayData = (CustomData *)context; |
| |
| if(!PlayData || !PlayData->engine || !PlayData->options) |
| { |
| g_print("player pointer is invalid!\n"); |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| return; |
| } |
| gplay_pconfigions *options = PlayData->options; |
| PlayEngine *engine = PlayData->engine; |
| |
| switch(EventID) |
| { |
| case EVENT_ID_EOS: |
| { |
| /* for auto test script */ |
| g_print("EOS Found\n"); |
| engine->stop((PlayEngineHandle)engine); |
| |
| if(!options->no_auto_next) |
| { |
| if(playlist_next(engine, options) != PLAYENGINE_SUCCESS) |
| { |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| }else{ |
| g_print("play next item successfully\n"); |
| } |
| }else{ |
| g_print("no auto next is on\n"); |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| } |
| |
| } |
| break; |
| |
| case EVENT_ID_ERROR: |
| { |
| const gchar * errstr = (gchar *)Eventpayload; |
| if(errstr) |
| g_print("gplay meet internal error: %s\n",errstr); |
| engine->stop((PlayEngineHandle)engine); |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| } |
| break; |
| |
| case EVENT_ID_STATE_CHANGE: |
| { |
| /* to do here to process state change */ |
| PlayEngineState *state = (PlayEngineState *)Eventpayload; |
| if(state) |
| g_print("State change from %s to %s\n",gst_element_state_get_name(state->old_st), |
| gst_element_state_get_name(state->new_st)); |
| } |
| break; |
| |
| case EVENT_ID_BUFFERING: |
| { |
| /* to do here to process buffering */ |
| const gint *percent = (gint *)Eventpayload; |
| if(options->handle_buffering){ |
| if(percent){ |
| g_print("\r\t\t\t\t\t\t%s %d%%", "buffering...", *percent); |
| |
| if(*percent == 0) |
| { |
| engine->pause((PlayEngineHandle)engine); |
| }else if(*percent >= 100) |
| { |
| engine->play((PlayEngineHandle)engine); |
| } |
| } |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| void |
| print_help() |
| { |
| g_print ("options :\n"); |
| g_print (" --quiet Disable playback status display updating\n\n"); |
| g_print (" --repeat Set gplay to playlist repeat mode.\n"); |
| g_print (" Use below option to specify your repeat times\n"); |
| g_print (" --repeat=PlayTimes\n\n"); |
| g_print (" --video-sink Specify the video sink instead of default sink\n"); |
| g_print (" Use below option to input your video sink name\n"); |
| g_print (" --video-sink=video_sink_name\n\n"); |
| g_print (" --audio-sink Specify the audio sink instead of default sink\n"); |
| g_print (" Use below option to input your audio sink name\n"); |
| g_print (" --audio-sink=audio_sink_name\n\n"); |
| g_print (" --text-sink Specify the text sink instead of default sink\n"); |
| g_print (" Use below option to input your text sink name\n"); |
| g_print (" --text-sink=text_sink_name\n\n"); |
| g_print (" --suburi Set subtitle path\n"); |
| g_print (" Use below option to input your pathname\n"); |
| g_print (" --suburi=pathname\n\n"); |
| } |
| |
| PlayEngineResult |
| parse_pconfigions(gplay_pconfigions *pconfig, |
| gint32 argc, |
| gchar* argv[]) |
| { |
| gint32 i; |
| |
| |
| pconfig->pl = createPlayList(); |
| if ((void *)pconfig->pl == NULL){ |
| printf("Can not create Playlist!!\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| |
| pconfig->play_times = -1; |
| |
| for (i=1;i<argc;i++){ |
| if (strlen(argv[i])) { |
| if (argv[i][0]=='-'){ |
| if ((strcmp(argv[i], "-h")==0)||(strcmp(argv[i], "--help")==0)){ |
| g_print ("Usage: gplay-1.0 [OPTIONS] PATH [PATH...]\n"); |
| print_help(); |
| goto err; |
| } |
| |
| if (strcmp(argv[i], "--quiet")==0){ |
| pconfig->display_refresh_frq = 0; |
| continue; |
| } |
| |
| if (strncmp(argv[i], "--repeat", 8)==0){ |
| if (argv[i][8]=='='){ |
| pconfig->play_times = atoi(&(argv[i][9])); |
| } |
| pconfig->repeat = PLAYER_REPEAT_PLAYLIST; |
| continue; |
| } |
| |
| if ((strncmp(argv[i], "--video-sink", 12)==0)){ |
| if (argv[i][12]=='='){ |
| pconfig->video_sink_name = &(argv[i][13]); |
| } |
| continue; |
| } |
| |
| if ((strncmp(argv[i], "--audio-sink", 12)==0)){ |
| if (argv[i][12]=='='){ |
| pconfig->audio_sink_name = &(argv[i][13]); |
| } |
| continue; |
| } |
| |
| if ((strncmp(argv[i], "--text-sink", 11)==0)) { |
| if (argv[i][11]=='=') { |
| pconfig->text_sink_name = &(argv[i][12]); |
| } |
| continue; |
| } |
| |
| if ((strncmp(argv[i], "--suburi", 8)==0)) { |
| if (argv[i][8]=='=') { |
| pconfig->suburi = &(argv[i][9]); |
| } |
| continue; |
| } |
| |
| if (strncmp(argv[i], "--timeout", 9)==0){ |
| if (argv[i][9]=='='){ |
| pconfig->timeout = atoi(&(argv[i][10])); |
| } |
| continue; |
| } |
| |
| if ((strncmp(argv[i], "--info-interval", 14)==0)){ |
| if (argv[i][14]=='='){ |
| pconfig->display_refresh_frq = atoi(&(argv[i][15])); |
| } |
| continue; |
| } |
| |
| if ((strcmp(argv[i], "--noautonext") == 0)) { |
| pconfig->no_auto_next = TRUE; |
| continue; |
| } |
| |
| if ((strcmp(argv[i], "--handle-buffering")==0)){ |
| pconfig->handle_buffering = TRUE; |
| continue; |
| } |
| |
| continue; |
| }else{ |
| |
| if(addItemAtTail(pconfig->pl, argv[i]) != PLAYENGINE_SUCCESS) |
| goto err; |
| continue; |
| } |
| } |
| } |
| |
| pconfig->current = getFirstItem(pconfig->pl); |
| if(pconfig->current == NULL) |
| { |
| g_print("NO File specified!!\n"); |
| goto err; |
| } |
| |
| return PLAYENGINE_SUCCESS; |
| |
| err: |
| if (pconfig->pl){ |
| destroyPlayList(pconfig->pl); |
| pconfig->pl=NULL; |
| } |
| return PLAYENGINE_FAILURE; |
| } |
| |
| |
| |
| void |
| display_thread_fun(gpointer data) |
| { |
| CustomData * PlayData = (CustomData *)data; |
| gchar str_repeated_mode[3][20] = {"(No Repeated)", "(List Repeated)", "(Current Repeated)"}; |
| |
| if(!PlayData || !PlayData->engine || !PlayData->options) |
| { |
| g_print("Invalid Custom Data pointer\n"); |
| return; |
| } |
| PlayEngine * engine = PlayData->engine; |
| gplay_pconfigions *options = PlayData->options; |
| |
| while(1) |
| { |
| if( TRUE == gexit_display_thread ) |
| { |
| g_print("Exit display thread\n"); |
| engine->stop_wait_state_change((PlayEngineHandle)engine); |
| return; |
| } |
| if( FALSE == gDisable_display ) |
| { |
| gchar str_player_state_rate[16]; |
| gchar str_volume[16]; |
| gchar* prepeated_mode = &(str_repeated_mode[options->repeat][0]); |
| guint64 hour, minute, second; |
| guint64 hour_d, minute_d, second_d; |
| guint64 duration=0; |
| guint64 elapsed=0; |
| GstState player_state = GST_STATE_NULL; |
| gdouble playback_rate = 0.0; |
| gboolean bmute = 0; |
| gdouble volume = 0.0; |
| |
| engine->get_duration((PlayEngineHandle)engine, &duration); |
| engine->get_position((PlayEngineHandle)engine, &elapsed); |
| engine->get_state((PlayEngineHandle)engine, &player_state); |
| engine->get_play_rate((PlayEngineHandle)engine, &playback_rate); |
| engine->get_mute((PlayEngineHandle)engine, &bmute); |
| engine->get_volume((PlayEngineHandle)engine, &volume); |
| |
| if(duration == GST_CLOCK_TIME_NONE || elapsed == GST_CLOCK_TIME_NONE) |
| continue; |
| |
| hour = (elapsed/ (gint64)3600000000000); |
| minute = (elapsed / (guint64)60000000000) - (hour * 60); |
| second = (elapsed / 1000000000) - (hour * 3600) - (minute * 60); |
| hour_d = (duration/ (guint64)3600000000000); |
| minute_d = (duration / (guint64)60000000000) - (hour_d * 60); |
| second_d = (duration / 1000000000) - (hour_d * 3600) - (minute_d * 60); |
| |
| switch(player_state) |
| { |
| case GST_STATE_PLAYING: |
| { |
| if( playback_rate > 1.0 && playback_rate <= 8.0 ) |
| { |
| sprintf(str_player_state_rate, "%s(%1.1fX)", "FF ", playback_rate); |
| } |
| if( playback_rate > 0.0 && playback_rate < 1.0 ) |
| { |
| sprintf(str_player_state_rate, "%s(%1.1fX)", "SF ", playback_rate); |
| } |
| if( playback_rate >= -8.0 && playback_rate <= -0.0 ) |
| { |
| sprintf(str_player_state_rate, "%s(%1.1fX)", "FB ", playback_rate); |
| } |
| if( playback_rate == 1.0 ) |
| { |
| sprintf(str_player_state_rate, "%s", "Playing "); |
| } |
| } |
| break; |
| |
| case GST_STATE_PAUSED: |
| sprintf(str_player_state_rate, "%s", "Pause "); |
| break; |
| |
| case GST_STATE_READY: |
| sprintf(str_player_state_rate, "%s", "Ready "); |
| |
| case GST_STATE_NULL: |
| sprintf(str_player_state_rate, "%s", "Stop "); |
| break; |
| |
| default: |
| sprintf(str_player_state_rate, "%s", "Unknown "); |
| break; |
| } |
| |
| if( bmute ) |
| { |
| sprintf(str_volume, "%s", "MUTE "); |
| } |
| else |
| { |
| sprintf(str_volume, "Vol=%.1lf", volume); |
| } |
| |
| g_print("\r[%s%s][%s][%02d:%02d:%02d/%02d:%02d:%02d]", |
| str_player_state_rate, prepeated_mode, str_volume, |
| (gint32)hour, (gint32)minute, (gint32)second, |
| (gint32)hour_d, (gint32)minute_d, (gint32)second_d); |
| |
| fflush (stdout); |
| } |
| sleep(1); |
| } |
| } |
| |
| void |
| print_metadata(PlayEngine *engine) |
| { |
| gint64 duration=0; |
| imx_metadata metadata; |
| gint32 i; |
| |
| if(!engine) |
| { |
| g_print("PlayEngine pointer invalid, print metadata failed\n"); |
| return; |
| } |
| |
| engine->get_metadata((PlayEngineHandle)engine, &metadata); |
| engine->get_duration((PlayEngineHandle)engine, &duration); |
| |
| /* g_print not support Chinese, should use printf when show metadata */ |
| printf("\nMedia URI: %s\n", metadata.pathname); |
| printf("\tContainer: %s\n", metadata.container); |
| printf("\tDuration: %d seconds\n", (gint32)(duration/1000000000)); |
| printf("\tTitle: %s\n", metadata.title); |
| printf("\tAritist: %s\n", metadata.artist); |
| printf("\tAlbum: %s\n", metadata.album); |
| printf("\tCreationDate: %s\n", metadata.year); |
| printf("\tGenre: %s\n", metadata.genre); |
| printf("\tAlbumartist: %s\n", metadata.albumartist); |
| printf("\tComposer: %s\n", metadata.composer); |
| printf("\tCopyright: %s\n", metadata.copyright); |
| printf("\tDescription: %s\n", metadata.description); |
| printf("\tPerformer: %s\n", metadata.performer); |
| printf("\tKeywords: %s\n", metadata.keywords); |
| printf("\tComment: %s\n", metadata.comment); |
| printf("\tTool: %s\n", metadata.tool); |
| printf("\tLocation latitude: %s\n", metadata.location_latitude); |
| printf("\tLocation longtitude: %s\n", metadata.location_longtitude); |
| printf("\tTrackCount: %d\n", metadata.track_count); |
| printf("\tTrackNumber: %d\n", metadata.track_number); |
| printf("\tDiscNumber: %d\n", metadata.disc_number); |
| printf("\tRating: %d\n", metadata.rating); |
| for (i=0; i<metadata.n_audio; i++) { |
| printf("Audio%d:\n", i); |
| printf("\tCodec: %s\n", metadata.audio_info[i].codec_type); |
| printf("\tSample Rate: %d\n", metadata.audio_info[i].samplerate); |
| printf("\tChannels: %d\n", metadata.audio_info[i].channels); |
| printf("\tBitrate: %d\n", metadata.audio_info[i].bitrate); |
| printf("\tLanguage Code: %s\n", metadata.audio_info[i].language); |
| } |
| |
| for (i=0; i<metadata.n_video; i++) { |
| printf("Video%d:\n", i); |
| printf("\tCodec: %s\n", metadata.video_info[i].codec_type); |
| printf("\tWidth: %d\n", metadata.video_info[i].width); |
| printf("\tHeight: %d\n", metadata.video_info[i].height); |
| printf("\tFrame Rate: %f\n", (float)metadata.video_info[i].framerate_numerator / (float)metadata.video_info[i].framerate_denominator); |
| printf("\tBitrate: %d\n", metadata.video_info[i].bitrate); |
| printf("\tLanguage Code: %s\n", metadata.video_info[i].language); |
| } |
| |
| for (i=0; i<metadata.n_subtitle; i++) { |
| printf("subtitle%d:\n", i); |
| printf("\tCodec: %s\n", metadata.subtitle_info[i].codec_type); |
| printf("\tLanguage Code: %s\n", metadata.subtitle_info[i].language); |
| } |
| } |
| |
| void |
| print_menu() |
| { |
| g_print("\n%s\n", FSL_PLAYENGINE_VERSION_STR); |
| g_print("\t[h]display the operation Help\n"); |
| g_print("\t[p]Play\n"); |
| g_print("\t[s]Stop\n"); |
| g_print("\t[e]Seek\n"); |
| g_print("\t[a]Pause when playing, play when paused\n"); |
| g_print("\t[v]Volume\n"); |
| g_print("\t[m]Switch to mute or not\n"); |
| g_print("\t[>]Play next file\n"); |
| g_print("\t[<]Play previous file\n"); |
| g_print("\t[r]Switch to repeated mode or not\n"); |
| g_print("\t[u]Select the video track\n"); |
| g_print("\t[d]Select the audio track\n"); |
| g_print("\t[b]Select the subtitle track\n"); |
| g_print("\t[f]Set full screen\n"); |
| g_print("\t[z]resize the width and height\n"); |
| g_print("\t[t]Rotate\n"); |
| g_print("\t[c]Setting play rate\n"); |
| g_print("\t[i]Display the metadata\n"); |
| g_print("\t[x]eXit\n"); |
| } |
| |
| static void |
| signal_handler(int sig) |
| { |
| switch(sig) |
| { |
| case SIGINT: |
| g_print(" Aborted by signal[%d] Interrupt...\n", sig); |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| break; |
| |
| case SIGTTIN: |
| /* Nothing need do */ |
| break; |
| |
| default: |
| break; |
| } |
| } |
| |
| static void |
| reset_signal(int sig, void *handler) |
| { |
| if(!handler) |
| return; |
| |
| struct sigaction act; |
| act.sa_handler = handler; |
| sigemptyset(&act.sa_mask); |
| act.sa_flags = 0; |
| sigaction(sig, &act, NULL); |
| } |
| |
| int |
| main(int argc,char *argv[]) |
| { |
| gchar sCommand[256]; |
| PlayEngine * playengine = NULL; |
| gplay_pconfigions options; |
| GThread * display_thread = NULL; |
| CustomData PlayData; |
| |
| reset_signal(SIGINT, signal_handler); |
| /* support gplay to run in backend */ |
| reset_signal(SIGTTIN, signal_handler); |
| |
| if( argc < 2 ) |
| { |
| g_print ("Use -h or --help to see help message.\n"); |
| g_print ("Usage: gplay-1.0 [OPTIONS] PATH [PATH...]\n"); |
| print_help(); |
| return PLAYENGINE_FAILURE; |
| } |
| |
| memset(&options, 0, sizeof(gplay_pconfigions)); |
| options.play_times = 0; |
| options.repeat = PLAYER_REPEAT_NONE; |
| options.no_auto_next = FALSE; |
| options.handle_buffering = FALSE; |
| options.display_refresh_frq = 1; |
| //strcpy(options.text_sink_name,"fakesink"); |
| |
| if(parse_pconfigions(&options, argc, argv) != PLAYENGINE_SUCCESS) |
| { |
| return PLAYENGINE_FAILURE; |
| } |
| |
| |
| /* create playback engine */ |
| playengine = play_engine_create(); |
| |
| /* check if the play engine is created successfully */ |
| if(!playengine) |
| { |
| g_print("Create play engine failed!\n"); |
| return PLAYENGINE_FAILURE; |
| } |
| |
| PlayData.engine = playengine; |
| PlayData.options = &options; |
| |
| if(options.timeout != 0) |
| { |
| playengine->set_state_change_timeout((PlayEngineHandle)playengine, options.timeout); |
| } |
| |
| if (!options.video_sink_name) |
| if(play_engine_checkfeature(PLAYENGINE_G2D)) { |
| options.video_sink_name = "overlaysink"; |
| }else { |
| options.video_sink_name = "imxv4l2sink"; |
| } |
| |
| g_print("Set VideoSink %s\n", options.video_sink_name); |
| playengine->set_video_sink((PlayEngineHandle)playengine, options.video_sink_name); |
| |
| if (options.audio_sink_name){ |
| g_print("Set AudioSink %s\n", options.audio_sink_name); |
| playengine->set_audio_sink((PlayEngineHandle)playengine, options.audio_sink_name); |
| } |
| |
| if (options.text_sink_name) { |
| g_print("Set TextSink %s\n", options.text_sink_name); |
| playengine->set_text_sink((PlayEngineHandle)playengine, options.text_sink_name); |
| } |
| if (options.suburi) |
| { |
| /* load usr define subtitle uri */ |
| g_print("Load subtitle: %s\n",options.suburi); |
| playengine->set_subtitle_uri((PlayEngineHandle)playengine, options.suburi); |
| }else |
| { |
| /* if there is dafault subtitle file, try to load - not support now*/ |
| |
| } |
| |
| playengine->reg_event_handler((PlayEngineHandle)playengine, &PlayData, event_callback); |
| |
| if(playengine->set_file(playengine,options.current) != PLAYENGINE_SUCCESS) |
| { |
| g_print("set file failed\n"); |
| if(options.pl) |
| destroyPlayList(options.pl); |
| options.pl = NULL; |
| if(playengine) |
| play_engine_destroy(playengine); |
| playengine = NULL; |
| return PLAYENGINE_FAILURE; |
| } |
| |
| if(options.display_refresh_frq != 0) |
| { |
| display_thread = g_thread_new("display_thread", (GThreadFunc)display_thread_fun, &PlayData); |
| } |
| |
| if(playengine->play((PlayEngineHandle)playengine) !=PLAYENGINE_SUCCESS) |
| { |
| g_print("try to play failed\n"); |
| if(options.pl) |
| destroyPlayList(options.pl); |
| options.pl = NULL; |
| if(playengine) |
| play_engine_destroy(playengine); |
| playengine = NULL; |
| |
| gexit_display_thread = TRUE; |
| if(display_thread) |
| g_thread_join(display_thread); |
| |
| return PLAYENGINE_FAILURE; |
| } |
| /* for auto test script */ |
| g_print("%s\n","fsl_player_play()"); |
| |
| fflush(stdout); |
| print_menu(); |
| |
| while(gexit_main == FALSE){ |
| sCommand[0] = ' '; |
| errno = 0; |
| if(scanf("%256s", sCommand) != 1){ |
| continue; |
| } |
| |
| switch( sCommand[0] ) |
| { |
| case 'h': // display the operation Help. |
| print_menu(); |
| break; |
| |
| case 'p': // Play. |
| { |
| GstState player_state = GST_STATE_NULL; |
| playengine->get_state((PlayEngineHandle)playengine,&player_state); |
| if (player_state == GST_STATE_NULL) { |
| playengine->set_file(playengine, options.current); |
| playengine->play(playengine); |
| } |
| } |
| break; |
| |
| case 's': // Stop |
| { |
| playengine->stop((PlayEngineHandle)playengine); |
| } |
| break; |
| |
| case 'a': // pAuse |
| { |
| GstState player_state = GST_STATE_NULL; |
| playengine->get_state((PlayEngineHandle)playengine, &player_state); |
| |
| if (player_state == GST_STATE_NULL) { |
| playengine->set_file(playengine, options.current); |
| playengine->play(playengine); |
| }else if(player_state == GST_STATE_PLAYING) |
| playengine->pause((PlayEngineHandle)playengine); |
| else if(player_state == GST_STATE_PAUSED) |
| playengine->play((PlayEngineHandle)playengine); |
| } |
| break; |
| |
| case 'e': // sEek |
| { |
| guint32 seek_point_sec = 0; |
| guint64 duration_ns = 0; |
| guint64 duration_sec = 0; |
| guint32 seek_portion = 0; |
| gboolean accurate_seek = FALSE;// |
| gint input_mode = -1; |
| gboolean seekable = FALSE; |
| |
| gDisable_display = TRUE; |
| playengine->get_seekable((PlayEngineHandle)playengine, &seekable); |
| if(!seekable){ |
| g_print("file is not seekable!\n"); |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| break; |
| } |
| playengine->get_duration((PlayEngineHandle)playengine, &duration_ns); |
| duration_sec = duration_ns / 1000000000; |
| //kb_restore_term(STDIN_FILENO); |
| |
| g_print("Select seek mode[Fast seek:0,Accurate seek:1]:"); |
| if(scanf("%d",&input_mode) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| |
| if( input_mode != 0 && input_mode != 1 ) |
| { |
| g_print("Invalid seek mode!\n"); |
| gDisable_display = FALSE; |
| break; |
| }else{ |
| accurate_seek = (gboolean)input_mode; |
| } |
| |
| g_print("%s seek to percentage[0:100] or second [t?]:", accurate_seek?"Accurate":"Normal"); |
| if(scanf("%256s",sCommand) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| if (sCommand[0]=='t'){ |
| seek_point_sec = atoi(&sCommand[1]); |
| }else{ |
| seek_portion = atoi(sCommand); |
| |
| if( seek_portion>100 ) |
| { |
| g_print("Invalid seek point!\n"); |
| gDisable_display = FALSE; |
| break; |
| } |
| seek_point_sec = (guint64)(seek_portion * duration_sec / 100); |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| playengine->seek((PlayEngineHandle)playengine, seek_point_sec, accurate_seek); |
| } |
| break; |
| |
| case 'v': //Volume |
| |
| { |
| gdouble volume; |
| g_print("Set volume[0-1.0]:"); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%lf",&volume) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| playengine->set_volume((PlayEngineHandle)playengine, volume); |
| } |
| break; |
| |
| case 'm': |
| { |
| gboolean mute_status = FALSE; |
| playengine->get_mute((PlayEngineHandle)playengine, &mute_status); |
| if(mute_status == FALSE) |
| { |
| playengine->set_mute((PlayEngineHandle)playengine, TRUE); |
| }else |
| { |
| playengine->set_mute((PlayEngineHandle)playengine, FALSE); |
| } |
| } |
| break; |
| |
| case 'c': // playing direction and speed Control. |
| { |
| gdouble playback_rate; |
| g_print("Set playing speed[-8,-4,-2,0.125,0.25,0.5,1,2,4,8]:"); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%lf",&playback_rate) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| playengine->set_play_rate((PlayEngineHandle)playengine, playback_rate); |
| } |
| break; |
| |
| case 'i': |
| print_metadata((PlayEngineHandle)playengine); |
| break; |
| |
| case 'x':// eXit |
| { |
| playengine->stop((PlayEngineHandle)playengine); |
| g_print("Ready to exit this app!\n"); |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| } |
| break; |
| |
| case 'r': // Switch to repeated mode or not |
| { |
| gint setrepeat; |
| g_print("input repeated mode[0 for no repeated,1 for play list repeated, 2 for current file repeated]:"); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d",&setrepeat) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| if( setrepeat<0 || setrepeat>2 ) |
| { |
| g_print("Invalid repeated mode!\n"); |
| } |
| else |
| { |
| options.repeat = setrepeat; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| } |
| break; |
| |
| case '>': // Play next file |
| g_print("next\n"); |
| playengine->stop((PlayEngineHandle)playengine); |
| if (playlist_next(playengine, &options) != PLAYENGINE_SUCCESS) |
| { |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| } |
| break; |
| |
| case '<': // Play previous file |
| g_print("previous\n"); |
| playengine->stop((PlayEngineHandle)playengine); |
| if(playlist_previous(playengine, &options) != PLAYENGINE_SUCCESS) |
| { |
| gexit_main = TRUE; |
| gexit_display_thread = TRUE; |
| set_alarm(1); |
| } |
| break; |
| |
| case 't': // Rotate 90 degree every time |
| { |
| gint rotate_value; |
| g_print("Set rotation between 0, 90, 180, 270: "); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d",&rotate_value) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| if(rotate_value != 0 && rotate_value != 90 && rotate_value != 180 && rotate_value != 270 ) |
| { |
| g_print("Invalid rotation value=%d, should input [0, 90, 180, 270]\n", rotate_value); |
| break; |
| } |
| playengine->set_rotate((PlayEngineHandle)playengine, rotate_value); |
| } |
| break; |
| |
| case 'z': // resize the width and height |
| { |
| DisplayArea area; |
| guint x = 0; |
| guint y = 0; |
| guint width = 0; |
| guint height = 0; |
| g_print("Input [x y width height]:"); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d %d %d %d", &x, &y, &width, &height) != 4) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| area.offsetx = x; |
| area.offsety = y; |
| area.width = width; |
| area.height = height; |
| |
| playengine->set_render_rect((PlayEngineHandle)playengine, area); |
| playengine->expose_video((PlayEngineHandle)playengine); |
| } |
| break; |
| |
| case 'f': |
| { |
| playengine->set_fullscreen((PlayEngineHandle)playengine); |
| playengine->expose_video((PlayEngineHandle)playengine); |
| } |
| break; |
| |
| case 'u': // Select the video track |
| { |
| gint32 video_track_no = 0; |
| gint32 total_video_no = 0; |
| guint64 elapsed=0; |
| playengine->get_video_num((PlayEngineHandle)playengine, &total_video_no); |
| g_print("input video track number[0,%d]:",total_video_no-1); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d",&video_track_no) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| if( video_track_no < 0 || video_track_no > total_video_no-1 ) |
| { |
| g_print("Invalid video track!\n"); |
| } |
| else |
| { |
| playengine->select_video((PlayEngineHandle)playengine, video_track_no); |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| } |
| break; |
| |
| case 'd': // Select the audio track |
| { |
| gint32 audio_track_no = 0; |
| gint32 total_audio_no = 0; |
| guint64 elapsed=0; |
| playengine->get_audio_num((PlayEngineHandle)playengine, &total_audio_no); |
| g_print("input audio track number[0,%d]:",total_audio_no-1); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d",&audio_track_no) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| if( audio_track_no < 0 || audio_track_no > total_audio_no-1 ) |
| { |
| g_print("Invalid audio track!\n"); |
| } |
| else |
| { |
| playengine->select_audio((PlayEngineHandle)playengine, audio_track_no); |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| } |
| break; |
| |
| case 'b': // Select the subtitle |
| { |
| gint32 subtitle_no = 0; |
| gint32 total_subtitle_no = 0; |
| playengine->get_subtitle_num((PlayEngineHandle)playengine, &total_subtitle_no); |
| g_print("input subtitle number[0,%d]:",total_subtitle_no-1); |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%d",&subtitle_no) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| if( subtitle_no < 0 || subtitle_no > total_subtitle_no-1 ) |
| { |
| g_print("Invalid subtitle track!\n"); |
| } |
| else |
| { |
| playengine->select_subtitle((PlayEngineHandle)playengine, subtitle_no); |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| } |
| break; |
| |
| case '*':// sleep 1 second |
| { |
| sleep(1); |
| } |
| break; |
| |
| case '#':// sleep 10 seconds |
| { |
| sleep(10); |
| } |
| break; |
| |
| case 'q': // Query information |
| { |
| g_print("Input query type[v:has video?, e:seekable?, s:state, p:position, u:duration, z:size, t:rotation, c:play rate]:\n"); |
| |
| //kb_restore_term(STDIN_FILENO); |
| gDisable_display = TRUE; |
| if(scanf("%256s",sCommand) != 1) |
| { |
| gDisable_display = FALSE; |
| break; |
| } |
| gDisable_display = FALSE; |
| //kb_set_raw_term(STDIN_FILENO); |
| |
| switch(sCommand[0]) |
| { |
| case 'v': |
| { |
| gint video_num = 0; |
| playengine->get_video_num((PlayEngineHandle)playengine, &video_num); |
| g_print("Number of Video Streams : %d\n", video_num); |
| } |
| break; |
| |
| case 'e': |
| { |
| gboolean seekable = FALSE; |
| playengine->get_seekable((PlayEngineHandle)playengine, &seekable); |
| g_print("Seekable : %s\n", seekable ? "Yes" : "No"); |
| } |
| break; |
| |
| case 's': |
| { |
| GstState player_state = GST_STATE_NULL; |
| gdouble playback_rate = 0.0; |
| playengine->get_state((PlayEngineHandle)playengine, &player_state); |
| playengine->get_play_rate((PlayEngineHandle)playengine, &playback_rate); |
| switch(player_state) |
| { |
| case GST_STATE_PLAYING: |
| { |
| if( playback_rate > 1.0 && playback_rate <= 8.0 ) |
| { |
| g_print("Current State : Fast Forward\n"); |
| } |
| if( playback_rate > 0.0 && playback_rate < 1.0 ) |
| { |
| g_print("Current State : Slow Forward\n"); |
| } |
| if( playback_rate >= -8.0 && playback_rate <= -0.0 ) |
| { |
| g_print("Current State : Fast Backward\n"); |
| } |
| if( playback_rate == 1.0 ) |
| { |
| g_print("Current State : Playing\n"); |
| } |
| } |
| break; |
| |
| case GST_STATE_PAUSED: |
| g_print("Current State : Paused\n"); |
| break; |
| |
| case GST_STATE_READY: |
| g_print("Current State : Ready\n"); |
| break; |
| |
| case GST_STATE_NULL: |
| g_print("Current State : Stopped\n"); |
| break; |
| |
| default: |
| g_print("Current State : Unknown\n"); |
| break; |
| } |
| } |
| break; |
| |
| case 'p': |
| { |
| gint64 pos = 0; |
| playengine->get_position((PlayEngineHandle)playengine, &pos); |
| g_print("Current playing position : %lld\n", pos); |
| } |
| break; |
| |
| case 'u': |
| { |
| gint64 duration = 0; |
| playengine->get_duration((PlayEngineHandle)playengine, &duration); |
| g_print("Duration : %lld\n", duration); |
| } |
| break; |
| |
| case 'z': |
| { |
| DisplayArea area = {0}; |
| playengine->get_display_area((PlayEngineHandle)playengine, &area); |
| g_print("Current video display area : %d %d %d %d\n", area.offsetx, area.offsety, area.width, area.height); |
| } |
| break; |
| |
| case 't': |
| { |
| gint32 rotation = 0; |
| playengine->get_rotate((PlayEngineHandle)playengine, &rotation); |
| g_print("Current rotation : %d\n", rotation); |
| } |
| break; |
| |
| case 'c': |
| { |
| gdouble playback_rate = 0.0; |
| playengine->get_play_rate((PlayEngineHandle)playengine, &playback_rate); |
| g_print("Current play rate : %1.1f\n", playback_rate); |
| } |
| break; |
| |
| default: |
| break; |
| } |
| } |
| break; |
| |
| default: |
| break; |
| } |
| fflush(stdout); |
| fflush(stdin); |
| } |
| |
| gboolean ismute = FALSE; |
| playengine->get_mute((PlayEngineHandle)playengine, &ismute); |
| if(ismute) |
| { |
| playengine->pause((PlayEngineHandle)playengine); |
| playengine->set_mute((PlayEngineHandle)playengine, FALSE); |
| } |
| playengine->set_volume((PlayEngineHandle)playengine, 1.0); |
| |
| /* for auto test script */ |
| g_print("FSL_PLAYENGINE_UI_MSG_EXIT\n"); |
| |
| if(options.pl) |
| destroyPlayList(options.pl); |
| options.pl = NULL; |
| if(playengine) |
| play_engine_destroy(playengine); |
| playengine = NULL; |
| if(display_thread) |
| g_thread_join(display_thread); |
| |
| /* for auto test script */ |
| g_print("fsl_player_deinit\n"); |
| |
| return PLAYENGINE_SUCCESS; |
| } |
