mm_player_example.c

00001 #include <glib.h>
00002 #include <gdk/gdkx.h>
00003 #include  <gtk/gtk.h>
00004 #include <mm_player.h>
00005 #include <string.h>
00006 
00007 enum {
00008     CURRENT_STATUS_MAINMENU     = 0,
00009     CURRENT_STATUS_FILENAME         = 1,
00010     CURRENT_STATUS_VOLUME       = 2,
00011     CURRENT_STATUS_POSITION         = 3,
00012 };
00013 
00014 GMainLoop   *g_loop;
00015 int         g_current_state;
00016 int         g_menu_state = CURRENT_STATUS_MAINMENU;
00017 MMHandleType g_player = 0;
00018 XID         g_video_xid = 0;
00019 
00020 #define MAX_STRING_LEN      255
00021 
00022 void freeattrs()
00023 {
00024     MMHandleType attrs = 0;
00025     char *string = NULL;
00026     void *data = NULL;
00027     int size;
00028     int *array = NULL;
00029     int count;
00030     
00031     /* Get player configuration */
00032     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_PROFILE, &attrs );
00033     if (attrs)
00034     {
00035     
00036         MMAttrsGetString(attrs, MM_PLAYER_PROFILE_URI, &string, &size);
00037         if(string)
00038         {
00039             free(string);
00040             string = NULL;
00041         }
00042 
00043         MMAttrsGetData(attrs, MM_PLAYER_PROFILE_PARAM, &data, &size);
00044         if (data)
00045         {
00046             free(data);
00047             data = NULL;
00048         }
00049         attrs = 0;
00050     }
00051 
00052     /* MM_PLAYER_ATTRS_CONTENT*/
00053     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_CONTENT, &attrs );
00054     if (attrs)
00055     {
00056     
00057         MMAttrsGetString(attrs, MM_PLAYER_CONTENT_VIDEO_CODEC, &string, &size);
00058         if(string)
00059         {
00060             free(string);
00061             string = NULL;
00062         }
00063 
00064         MMAttrsGetString(attrs, MM_PLAYER_CONTENT_AUDIO_CODEC, &string, &size);
00065         if(string)
00066         {
00067             free(string);
00068             string = NULL;
00069         }
00070         attrs = 0;
00071     }
00072         
00073 
00074     /* MM_PLAYER_ATTRS_TAG*/
00075     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_TAG, &attrs );
00076     if (attrs)
00077     {
00078     
00079         MMAttrsGetString(attrs, MM_PLAYER_TAG_ARTIST, &string, &size);
00080         if(string)
00081         {
00082             free(string);
00083             string = NULL;
00084         }
00085 
00086         MMAttrsGetString(attrs, MM_PLAYER_TAG_TITLE, &string, &size);
00087         if(string)
00088         {
00089             free(string);
00090             string = NULL;
00091         }
00092 
00093         MMAttrsGetString(attrs, MM_PLAYER_TAG_ALBUM, &string, &size);
00094         if(string)
00095         {
00096             free(string);
00097             string = NULL;
00098         }
00099 
00100         MMAttrsGetString(attrs, MM_PLAYER_TAG_GENRE, &string, &size);
00101         if(string)
00102         {
00103             free(string);
00104             string = NULL;
00105         }
00106 
00107         MMAttrsGetString(attrs, MM_PLAYER_TAG_AUTHOR, &string, &size);
00108         if(string)
00109         {
00110             free(string);
00111             string = NULL;
00112         }
00113 
00114         MMAttrsGetString(attrs, MM_PLAYER_TAG_COPYRIGHT, &string, &size);
00115         if(string)
00116         {
00117             free(string);
00118             string = NULL;
00119         }
00120 
00121         MMAttrsGetString(attrs, MM_PLAYER_TAG_DATE, &string, &size);
00122         if(string)
00123         {
00124             free(string);
00125             string = NULL;
00126         }
00127 
00128         MMAttrsGetString(attrs, MM_PLAYER_TAG_DESCRIPTION, &string, &size);
00129         if(string)
00130         {
00131             free(string);
00132             string = NULL;
00133         }
00134         
00135         attrs = 0;
00136     }
00137 
00138     
00139     /* Get player configuration */
00140     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_DISPLAY, &attrs );
00141     if (attrs)
00142     {
00143     
00144         MMAttrsGetData(attrs, MM_PLAYER_DISPLAY_DEVICE, &data, &size);
00145         if (data)
00146         {
00147             free(data);
00148             data = NULL;
00149         }
00150 
00151         MMAttrsGetArray(attrs, MM_PLAYER_DISPLAY_ROTATION, &array, &count);
00152         if (array)
00153         {
00154             free(array);
00155             array = NULL;
00156         }
00157         attrs = 0;
00158     }
00159 
00160 }
00161 
00162 static bool msg_callback(int message, MMMessageType *param, void *user_param)
00163 {
00164     switch (message) {
00165         case MM_MESSAGE_ERROR:
00166             // g_print("error : code = %d\n", param->code);
00167             break;
00168 
00169         case MM_MESSAGE_WARNING:
00170             // g_print("warning : code = %d\n", param->code);
00171             break;
00172 
00173         case MM_MESSAGE_TIME_ELAPSED:
00174             // g_print("elapsed : %d sec\n", param->time.elapsed);
00175             break;
00176 
00177         case MM_MESSAGE_END_OF_STREAM:
00178             g_print("end of stream\n");
00179             MMPlayerUnrealize(g_player);
00180             freeattrs();
00181             MMPlayerDestroy(g_player);
00182             g_player = 0;
00183             break;
00184 
00185         case MM_MESSAGE_STATE_CHANGED:
00186             g_current_state = param->state.current;
00187             g_print("current state : %d\n", g_current_state);
00188             break;
00189 
00190         default:
00191             return FALSE;
00192     }
00193 
00194     return TRUE;
00195 }
00196 
00197 static void input_filename(char *filename)
00198 {
00199     int len = strlen(filename);
00200     int size;
00201     int err = 0;
00202 
00203     if (len > 0 && len < MAX_STRING_LEN) {
00204         MMHandleType prof_prop, dis_prop;
00205 
00206         MMPlayerUnrealize(g_player);
00207         freeattrs();
00208         MMPlayerDestroy(g_player);
00209         g_player = 0;
00210 
00211         MMPlayerCreate(&g_player);
00212         MMPlayerSetMessageCallback(g_player, msg_callback, (void*)g_player);
00213 
00214         /* set player configuration */
00215         MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_PROFILE, &prof_prop);
00216 
00217         size = strlen(filename);3
00218         MMAttrsSetString(prof_prop, MM_PLAYER_PROFILE_URI, filename, size);
00219         MMAttrsSetInt(prof_prop, MM_PLAYER_PROFILE_PRIORITY, 0);
00220         MMAttrsSetData(prof_prop, MM_PLAYER_PROFILE_PARAM, (void*)g_player, sizeof(g_player));
00221 
00222         MMPlayerSetAttrs(g_player, MM_PLAYER_ATTRS_PROFILE, prof_prop);
00223 
00224         MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_DISPLAY, &dis_prop);
00225         MMAttrsSetData(dis_prop, MM_PLAYER_DISPLAY_DEVICE, (void*)(&g_video_xid), sizeof(&g_video_xid));
00226         MMPlayerSetAttrs(g_player, MM_PLAYER_ATTRS_DISPLAY, dis_prop);
00227 
00228         err = MMPlayerRealize(g_player);
00229         
00230         if(!err)
00231         {
00232             /* wait until realized */
00233             while (g_current_state != MM_PLAYER_STATE_READY) {
00234                 ;
00235             }
00236         }
00237     }
00238 }
00239 
00240 static void set_volume(int volume)
00241 {
00242     MMPlayerVolumeType volume_val = {0,};
00243     int i;
00244 
00245     for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++) {
00246         volume_val.level[i] = volume;
00247     }
00248 
00249     MMPlayerSetVolume(g_player, &volume_val);
00250 }
00251 
00252 static void get_volume()
00253 {
00254     MMPlayerVolumeType volume = {0,};
00255     int i;
00256 
00257     MMPlayerGetVolume(g_player, &volume);
00258 
00259     g_print("[ volume ]\n");
00260     for (i = 0; i < MM_VOLUME_CHANNEL_NUM; i++) {
00261         g_print("    channel [%d] = %d\n", i, volume.level[i]);
00262     }
00263 }
00264 
00265 static void player_play()
00266 {
00267     int bRet = FALSE;
00268 
00269     bRet = MMPlayerStart(g_player);
00270 
00271     printf("%s ret:%d\n", __FUNCTION__, bRet);
00272 }
00273 
00274 static void player_stop()
00275 {
00276     int bRet = FALSE;
00277 
00278     bRet = MMPlayerStop(g_player);
00279 
00280     printf("%s ret:%d\n", __FUNCTION__, bRet);
00281 }
00282 
00283 static void player_resume()
00284 {
00285     int bRet = FALSE;
00286 
00287     bRet = MMPlayerResume(g_player);
00288 
00289     printf("%s ret:%d\n", __FUNCTION__, bRet);
00290 }
00291 
00292 static void player_pause()
00293 {
00294     int bRet = FALSE;
00295 
00296     bRet = MMPlayerPause(g_player);
00297 
00298     printf("%s ret:%d\n", __FUNCTION__, bRet);
00299 }
00300 
00301 static void get_position()
00302 {
00303     MMPlayerPosFormatType format = MM_PLAYER_POS_FORMAT_TIME;
00304     
00305     int position;
00306     int error = 0;
00307 
00308     error = MMPlayerGetPosition(g_player, format, &position);
00309 
00310     if (!error){
00311         g_print("Pos: %ld\n", position);
00312     }
00313 }
00314 
00315 static void set_position(int position)
00316 {
00317     MMPlayerPosFormatType format = MM_PLAYER_POS_FORMAT_TIME;
00318 
00319     MMPlayerSetPosition(g_player, format, position);
00320 }
00321 
00322 static void print_info()
00323 {
00324     MMHandleType tag_prop = 0;
00325     MMHandleType content_prop = 0;
00326     char *string;3
00327     int size = 0;
00328     int tracknum = 0;
00329 
00330     /* set player configuration */
00331     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_TAG, &tag_prop );
00332     if (tag_prop == 0)
00333         return;
00334 
00335     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_ARTIST, &string, &size);
00336     printf("artist: %s\n", string);
00337     
00338     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_TITLE, &string, &size);
00339     printf("title: %s\n", string);
00340 
00341     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_ALBUM, &string, &size);
00342     printf("album: %s\n", string);
00343     
00344     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_GENRE, &string, &size);
00345     printf("genre: %s\n", string);
00346 
00347     // printf("author: %s\n", MMAttrsGetString(tag_prop, MM_PLAYER_TAG_AUTHOR));
00348 
00349     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_COPYRIGHT, &string, &size);
00350     printf("copyright: %s\n", string);
00351 
00352     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_DATE, &string, &size);
00353     printf("date: %s\n", string);
00354 
00355     MMAttrsGetString(tag_prop, MM_PLAYER_TAG_DESCRIPTION, &string, &size);
00356     printf("description: %s\n", string);
00357 
00358     MMAttrsGetInt(tag_prop, MM_PLAYER_TAG_TRACK_NUM, &tracknum);
00359     printf("track num: %d\n", tracknum);    
00360 
00361 
00362     MMPlayerGetAttrs(g_player, MM_PLAYER_ATTRS_CONTENT, &content_prop);
00363     if (content_prop == 0)
00364         return;
00365 
00366     MMAttrsGetString(content_prop, MM_PLAYER_CONTENT_AUDIO_CODEC, &string, &size);
00367     printf("audio codec: %s\n", string); 
00368 
00369     MMAttrsGetString(content_prop, MM_PLAYER_CONTENT_VIDEO_CODEC, &string, &size);
00370     printf("video codec: %s\n", string);    
00371 
00372     
00373 }
00374 
00375 static void quit_program()
00376 {
00377     g_print("exit program\n");
00378     MMPlayerUnrealize(g_player);
00379     freeattrs();
00380     MMPlayerDestroy(g_player);
00381     g_player = 0;
00382     g_main_loop_quit(g_loop);
00383 }
00384 
00385 static void displaymenu()
00386 {
00387     g_print("\n");
00388     g_print("**Limo API Test\n");
00389     if (g_menu_state == CURRENT_STATUS_MAINMENU) {
00390         g_print("**a. Initialize Media\n");
00391         g_print("**b. Play\n");
00392         g_print("**c. Stop\n");
00393         g_print("**d. Resume\n");
00394         g_print("**e. Pause\n");
00395         g_print("**f. Set Volume\n");
00396         g_print("**g. Get Volume\n");
00397         g_print("**h. Set Position\n");
00398         g_print("**i. Get Position\n");
00399         g_print("**j. Print Information\n");
00400         g_print("**q. Quit Program\n");
00401     } else if (g_menu_state == CURRENT_STATUS_FILENAME) {
00402         g_print("*** input mediapath.\n");
00403     } else if (g_menu_state == CURRENT_STATUS_VOLUME) {
00404         g_print("*** input volume value.\n");
00405     } else if (g_menu_state == CURRENT_STATUS_POSITION) {
00406         g_print("*** input position value.\n");
00407     } else {
00408         g_print("*** unknown status.\n");
00409         quit_program();
00410     }
00411     g_print(" >>> ");
00412 }
00413 
00414 gboolean timeout_menu_display(void* data)
00415 {
00416     displaymenu();
00417     return FALSE;
00418 }
00419 
00420 static void interpret (char *cmd)
00421 {
00422     switch (g_menu_state)
00423         {
00424         case CURRENT_STATUS_MAINMENU:
00425             if (strncmp(cmd, "a", 1) == 0) {
00426                 g_menu_state = CURRENT_STATUS_FILENAME;
00427             } else if (strncmp(cmd, "b", 1) == 0) {
00428                 player_play();
00429             } else if (strncmp(cmd, "c", 1) == 0) {
00430                 player_stop();
00431             } else if (strncmp(cmd, "d", 1) == 0) {
00432                 player_resume();
00433             } else if (strncmp(cmd, "e", 1) == 0) {
00434                 player_pause();
00435             } else if (strncmp(cmd, "f", 1) == 0) {
00436                 g_menu_state = CURRENT_STATUS_VOLUME;
00437             } else if (strncmp(cmd, "g", 1) == 0) {
00438                 get_volume();
00439             } else if (strncmp(cmd, "h", 1) == 0) {
00440                 g_menu_state = CURRENT_STATUS_POSITION;
00441             } else if (strncmp(cmd, "i", 1) == 0) {
00442                 get_position();
00443             } else if (strncmp(cmd, "j", 1) == 0) {
00444                 print_info();
00445             } else if (strncmp(cmd, "q", 1) == 0) {
00446                 quit_program();
00447             } else {
00448                 g_print("unknown menu\n");
00449             }
00450             break;
00451 
00452         case CURRENT_STATUS_FILENAME:
00453             input_filename(cmd);
00454             g_menu_state = CURRENT_STATUS_MAINMENU;
00455             break;
00456 
00457         case CURRENT_STATUS_VOLUME:
00458             {
00459                 gdouble volume = atoi(cmd);
00460                 set_volume(volume);
00461             }
00462             g_menu_state = CURRENT_STATUS_MAINMENU;
00463             break;
00464 
00465         case CURRENT_STATUS_POSITION:
00466             {
00467                 unsigned long position = atol(cmd);
00468                 set_position(position);
00469             }
00470             g_menu_state = CURRENT_STATUS_MAINMENU;
00471             break;
00472 
00473     }
00474 
00475     g_timeout_add(100, timeout_menu_display, 0);
00476 }
00477 
00478 gboolean input (GIOChannel *channel)
00479 {
00480     char buf[MAX_STRING_LEN + 3];
00481     gsize read;
00482 
00483     g_io_channel_read(channel, buf, MAX_STRING_LEN, &read);
00484     buf[read] = '\0';
00485     g_strstrip(buf);
00486     interpret (buf);
00487     return TRUE;
00488 }
00489 
00490 void disturb_closing_video_window(GtkWindow *video_window, gpointer data)
00491 {
00492     printf("%s\n", __FUNCTION__);
00493 }
00494 
00495 int main(int argc, char *argv[])
00496 {
00497     GtkWidget *video_area;
00498     GIOChannel *stdin_channel;
00499 
00500     gtk_init(&argc, &argv);
00501 
00502     stdin_channel = g_io_channel_unix_new(0);
00503     g_io_add_watch(stdin_channel, G_IO_IN, (GIOFunc)input, NULL);
00504 
00505     video_area = gtk_window_new(GTK_WINDOW_TOPLEVEL);
00506     g_signal_connect(GTK_OBJECT(video_area), "destroy", GTK_SIGNAL_FUNC(disturb_closing_video_window), NULL);   
00507     gtk_widget_show(video_area);
00508     
00509     g_video_xid = GDK_WINDOW_XWINDOW(GTK_WIDGET(video_area)->window);   
00510 
00511     displaymenu();
00512 
00513     g_loop = g_main_loop_new(NULL, FALSE);
00514 
00515     g_main_loop_run(g_loop);
00516 
00517     return 0;
00518 }

Generated on Mon Mar 31 01:01:00 2008 by  doxygen 1.5.4