test/wav_player_test.c

   1 /*
   2 * Copyright (c) 2011-2016 Samsung Electronics Co., Ltd All Rights Reserved
   3 *
   4 * Licensed under the Apache License, Version 2.0 (the "License");
   5 * you may not use this file except in compliance with the License.
   6 * You may obtain a copy of the License at
   7 *
   8 * http://www.apache.org/licenses/LICENSE-2.0
   9 *
  10 * Unless required by applicable law or agreed to in writing, software
  11 * distributed under the License is distributed on an "AS IS" BASIS,
  12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13 * See the License for the specific language governing permissions and
  14 * limitations under the License.
  15 */
  16
  17
  18
  19 #include <stdio.h>
  20 #include <wav_player_internal.h>
  21 #include <sound_manager.h>
  22 #include <sound_manager_internal.h>
  23 #include <glib.h>
  24 #include <unistd.h>
  25 #include <string.h>
  26 #include <stdlib.h>
  27 #include <getopt.h>
  28 #include <signal.h>
  29
  30 #define FILE_PATH_MAX   128
  31 #define DEFAULT_FILE    "/usr/share/sounds/alsa/Front_Center.wav"
  32
  33 static GMainLoop *g_mainloop = NULL;
  34 static int gid = -1;
  35 struct sigaction sig_int_old_action;
  36
  37 void help()
  38 {
  39         printf("Usage : ");
  40         printf("wav_player_test [OPTION]\n\n"
  41                    "  -f, --file                file path to play\n"
  42                    "  -s, --streamtype          stream type (0:media(default), 1:system, 2:notification, 3:solo)\n"
  43                    "  -i, --iterate             how many times to play\n"
  44                    "  -h, --help                help\n");
  45 }
  46
  47 void _player_stop_cb(int id, void *user_data)
  48 {
  49         printf("complete id = %d,%p\n", id, user_data);
  50         sound_manager_destroy_stream_information((sound_stream_info_h)user_data);
  51         g_main_loop_quit(g_mainloop);
  52 }
  53
  54 void stream_focus_cb(sound_stream_info_h stream_info, sound_stream_focus_change_reason_e reason, const char *extra_info, void *user_data)
  55 {
  56         return;
  57 }
  58
  59 void wav_play_test(const char* file_path, int iterate, int stream_type)
  60 {
  61         int ret = 0;
  62         int i;
  63         sound_stream_info_h stream_info;
  64         sound_stream_type_e type;
  65
  66         if (iterate <= 0 || file_path == NULL || (stream_type > 3 || stream_type < 0)) {
  67                 printf("invalid param, iterate(%d), file_path(%s), stream_type(%d)\n", iterate, file_path, stream_type);
  68                 return;
  69         }
  70
  71         switch (stream_type) {
  72         case 0:
  73                 type = SOUND_STREAM_TYPE_MEDIA;
  74                 break;
  75         case 1:
  76                 type = SOUND_STREAM_TYPE_SYSTEM;
  77                 break;
  78         case 2:
  79                 type = SOUND_STREAM_TYPE_NOTIFICATION;
  80                 break;
  81         case 3:
  82                 type = SOUND_STREAM_TYPE_SOLO;
  83                 break;
  84         }
  85
  86         if (stream_type == 3) {
  87                 if (sound_manager_create_stream_information_internal(type, stream_focus_cb, NULL, &stream_info)) {
  88                         printf("failed to create stream info internal\n");
  89                         return;
  90                 }
  91         } else {
  92                 if (sound_manager_create_stream_information(type, stream_focus_cb, NULL, &stream_info)) {
  93                         printf("failed to create stream info\n");
  94                         return;
  95                 }
  96         }
  97
  98         printf("Play Wav, File Path : %s, Iterate : %d\n", file_path, iterate);
  99         ret = wav_player_start_loop(file_path, stream_info, iterate, _player_stop_cb, (void*)stream_info, &gid);
 100         printf("wav_player_start(%d)(id=%d) ret = %d\n", i, gid, ret);
 101         if (ret) {
 102                 sound_manager_destroy_stream_information(stream_info);
 103                 return;
 104         }
 105
 106         g_mainloop = g_main_loop_new(NULL, 0);
 107         g_main_loop_run(g_mainloop);
 108 }
 109
 110 void __sig_handler(int signo)
 111 {
 112         sigset_t old_mask, all_mask;
 113         sigfillset(&all_mask);
 114         sigprocmask(SIG_BLOCK, &all_mask, &old_mask);
 115         sigprocmask(SIG_SETMASK, &old_mask, NULL);
 116
 117         printf("sig.num(%d)\n", signo);
 118
 119         switch (signo) {
 120         case SIGINT:
 121                 if (gid > -1) {
 122                         printf("stop wav-player\n");
 123                         wav_player_stop(gid);
 124                 }
 125                 sigaction(SIGINT, &sig_int_old_action, NULL);
 126                 raise(signo);
 127                 break;
 128         default:
 129                 break;
 130         }
 131 }
 132
 133 int main(int argc, char**argv)
 134 {
 135         int iterate = 1;
 136         int stream_type = 0;
 137         char file_path[FILE_PATH_MAX] = DEFAULT_FILE;
 138         struct sigaction sig_action;
 139         sig_action.sa_handler = __sig_handler;
 140         sig_action.sa_flags = SA_NOCLDSTOP;
 141         sigemptyset(&sig_action.sa_mask);
 142         sigaction(SIGINT, &sig_action, &sig_int_old_action);
 143
 144         while (1) {
 145                 int opt;
 146                 int opt_idx = 0;
 147
 148                 static struct option long_options[] = {
 149                         {"iterate"    , required_argument, 0, 'i'},
 150                         {"file"       , required_argument, 0, 'f'},
 151                         {"streamtype" , required_argument, 0, 's'},
 152                         { 0, 0, 0, 0 }
 153                 };
 154
 155                 if ((opt = getopt_long(argc, argv, "i:f:s:", long_options, &opt_idx)) == -1)
 156                         break;
 157
 158                 switch (opt) {
 159                 case 'f':
 160                         strncpy(file_path, optarg, FILE_PATH_MAX - 1);
 161                         file_path[FILE_PATH_MAX - 1] = '\0';
 162                         break;
 163                 case 'i':
 164                         iterate = atoi(optarg);
 165                         break;
 166                 case 's':
 167                         stream_type = atoi(optarg);
 168                         break;
 169                 case 'h':
 170                 default:
 171                         help();
 172                         return 0;
 173                 }
 174         }
 175
 176         wav_play_test(file_path, iterate, stream_type);
 177
 178         return 0;
 179 }