src/mm_player_utils.c

   1 /*
   2  * libmm-player
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: JongHyuk Choi <jhchoi.choi@samsung.com>, YeJin Cho <cho.yejin@samsung.com>, YoungHwan An <younghwan_.an@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include <stdio.h>
  23 #include <string.h>
  24 #include <unistd.h>
  25 #include <sys/stat.h>
  26 #include <sys/socket.h>
  27 #include <netinet/in.h>
  28 #include <arpa/inet.h>
  29 #include <mm_debug.h>
  30 #include "mm_player_utils.h"
  31
  32 bool util_exist_file_path(const char *file_path)
  33 {
  34         debug_log("\n");
  35
  36         if (!file_path || !strlen(file_path))
  37                 return FALSE;
  38
  39         int res = access(file_path, R_OK);
  40         if (res)
  41                 return FALSE;
  42
  43         return TRUE;
  44 }
  45
  46 bool util_write_file_backup(const char *backup_path, char *data_ptr, int data_size)
  47 {
  48         debug_log("\n");
  49
  50         FILE *fp = NULL;
  51         int wsize = 0;
  52
  53         fp = fopen(backup_path, "wb");
  54         if (!fp)
  55                 return FALSE;
  56
  57         wsize = fwrite(data_ptr, sizeof(char), data_size, fp);
  58
  59         fclose(fp);
  60
  61         if (wsize != data_size) {
  62                 if (!access(backup_path, R_OK))
  63                         remove(backup_path);
  64
  65                 debug_error("No space to write!\n");
  66
  67                 return FALSE;
  68         }
  69
  70         return TRUE;
  71 }
  72
  73 #if 1 //tskim:MidiModuleRequires:+: for Midi player
  74 bool util_remove_file_backup(const char *backup_path)
  75 {
  76         debug_log("\n");
  77
  78         if (!backup_path || !strlen(backup_path))
  79                 return FALSE;
  80
  81 /*
  82      Prevent defect patch. CID:22389 Checker:TOTCU
  83         int res = access(backup_path, R_OK);
  84         if (!res)
  85 */
  86                 remove(backup_path);
  87
  88         return TRUE;
  89 }
  90 #endif
  91
  92 #define DETECTION_PREFIX_SIZE   20
  93 //bool util_is_midi_type_by_mem(void *mem, int size)
  94 int util_is_midi_type_by_mem(void *mem, int size)
  95 {
  96         debug_log("\n");
  97
  98         const char *p = (const char *)mem;
  99
 100         if (size < DETECTION_PREFIX_SIZE)
 101                 return MM_AUDIO_CODEC_INVALID; //FALSE;         // sbs:+:080903
 102
 103         /* mmf file detection */
 104         if (p[0] == 'M' && p[1] == 'M' && p[2] == 'M' && p[3] == 'D') {
 105                 debug_log("MM_AUDIO_CODEC_MMF\n");
 106                 return MM_AUDIO_CODEC_MMF; // TRUE;// sbs:+:080903
 107         }
 108
 109         /* midi file detection */
 110         if (p[0] == 'M' && p[1] == 'T' && p[2] == 'h' && p[3] == 'd') {
 111                 debug_log ("MM_AUDIO_CODEC_MIDI, %d\n", MM_AUDIO_CODEC_MIDI);
 112                 return MM_AUDIO_CODEC_MIDI;//TRUE;// sbs:+:080903
 113         }
 114         /* mxmf file detection */ // sbs:+:080903
 115         if (p[0] == 'X' && p[1] == 'M' && p[2] == 'F' && p[3] == '_') {
 116                 debug_log ("MM_AUDIO_CODEC_MXMF\n");
 117                 return MM_AUDIO_CODEC_MXMF;
 118         }
 119
 120         /* wave file detection */
 121         if (p[0] == 'R' && p[1] == 'I' && p[2] == 'F' && p[3] == 'F' &&
 122                 p[8] == 'W' && p[9] == 'A' && p[10] == 'V' && p[11] == 'E' &&
 123                 p[12] == 'f' && p[13] == 'm' && p[14] == 't') {
 124                 debug_log ("MM_AUDIO_CODEC_WAVE\n");
 125                 return MM_AUDIO_CODEC_WAVE;//TRUE;// sbs:+:080903
 126         }
 127         /* i-melody file detection */ // sbs:+:080903
 128         if (memcmp(p, "BEGIN:IMELODY", 13) == 0)
 129         {
 130                 debug_log ("MM_AUDIO_CODEC_IMELODY\n");
 131                 return MM_AUDIO_CODEC_IMELODY;
 132         }
 133
 134         return MM_AUDIO_CODEC_INVALID;//FALSE; // sbs:+:080903
 135 }
 136
 137 //bool util_is_midi_type_by_file(const char *file_path)
 138 int util_is_midi_type_by_file(const char *file_path)
 139 {
 140         debug_log("\n");
 141
 142         struct stat file_attrib;
 143         FILE *fp = NULL;
 144         char prefix[DETECTION_PREFIX_SIZE] = {0,};
 145         int size;
 146
 147         if (!file_path)
 148                 return FALSE;
 149
 150         /* Prevent defect patch. CID: 22388 Checker: TOCTOU */
 151         fp = fopen(file_path, "r");
 152
 153         if (!fp)
 154         return FALSE;
 155
 156         memset(&file_attrib, 0, sizeof(file_attrib));
 157
 158         if (stat(file_path, &file_attrib) != 0)
 159         {
 160                 fclose(fp);
 161                 return FALSE;
 162         }
 163
 164         size = (int) file_attrib.st_size;
 165
 166         if (size < DETECTION_PREFIX_SIZE)
 167         {
 168                 fclose(fp);
 169                 return FALSE;
 170         }
 171
 172         size = fread(prefix, sizeof(char), DETECTION_PREFIX_SIZE, fp);
 173
 174         fclose(fp);
 175
 176         return util_is_midi_type_by_mem(prefix, size);
 177 }
 178
 179 /* messages are treated as warnings bcz those code should not be checked in.
 180  * and no error handling will supported for same manner.
 181  */
 182 gboolean
 183 __util_gst_pad_probe(GstPad *pad, GstBuffer *buffer, gpointer u_data)
 184 {
 185         gint flag = (gint) u_data;
 186         GstElement* parent = NULL;
 187         gboolean ret = TRUE;
 188
 189         /* show name as default */
 190         parent = (GstElement*)gst_object_get_parent(GST_OBJECT(pad));
 191         debug_warning("PAD PROBE : %s:%s\n", GST_ELEMENT_NAME(parent), GST_PAD_NAME(pad));
 192
 193         /* show time stamp */
 194         if ( flag & MM_PROBE_TIMESTAMP )
 195         {
 196                 debug_warning("ts : %u:%02u:%02u.%09u\n",  GST_TIME_ARGS(GST_BUFFER_TIMESTAMP(buffer)));
 197         }
 198
 199         /* show buffer size */
 200         if ( flag & MM_PROBE_BUFFERSIZE )
 201         {
 202                 debug_warning("buffer size : %ud\n", GST_BUFFER_SIZE(buffer));
 203         }
 204
 205         /* show buffer duration */
 206         if ( flag & MM_PROBE_BUFFER_DURATION )
 207         {
 208                 debug_warning("dur : %lld\n", GST_BUFFER_DURATION(buffer));
 209         }
 210
 211         /* show buffer caps */
 212         if ( flag & MM_PROBE_CAPS )
 213         {
 214                 debug_warning("caps : %s\n", gst_caps_to_string(GST_BUFFER_CAPS(buffer)));
 215         }
 216
 217         /* drop buffer if flag is on */
 218         if ( flag & MM_PROBE_DROP_BUFFER )
 219         {
 220                 debug_warning("dropping\n");
 221                 ret = FALSE;
 222         }
 223
 224         /* show clock time */
 225         if ( flag & MM_PROBE_CLOCK_TIME )
 226         {
 227                 GstClock* clock = NULL;
 228                 GstClockTime now = GST_CLOCK_TIME_NONE;
 229
 230                 clock = GST_ELEMENT_CLOCK ( parent );
 231
 232                 if ( clock )
 233                 {
 234                         now = gst_clock_get_time( clock );
 235                         debug_warning("clock time : %" GST_TIME_FORMAT "\n", GST_TIME_ARGS( now ));
 236                 }
 237         }
 238
 239         if ( parent )
 240                 gst_object_unref(parent);
 241
 242         return ret;
 243 }
 244
 245 char**
 246 util_get_cookie_list ( const char *cookies )
 247 {
 248         char **cookie_list = NULL;
 249         char *temp = NULL;
 250         gint i = 0;
 251
 252         if ( !cookies || !strlen(cookies) )
 253                 return NULL;
 254
 255         debug_log("cookies : %d[bytes] - %s \n", strlen(cookies), cookies);
 256
 257         temp = g_strdup(cookies);
 258
 259         /* trimming. it works inplace */
 260         g_strstrip(temp);
 261
 262         /* split */
 263         cookie_list = g_strsplit(temp, ";", 100);
 264
 265         for ( i = 0; i < g_strv_length(cookie_list); i++ )
 266         {
 267                 if ( cookie_list[i] && strlen(cookie_list[i]) )
 268                 {
 269                         g_strstrip(cookie_list[i]);
 270                         debug_log("cookie_list[%d] : %d[bytes] - %s \n", i, strlen(cookie_list[i]), cookie_list[i]);
 271                 }
 272                 else
 273                 {
 274                         cookie_list[i][0]='\0';
 275                 }
 276         }
 277
 278         if (temp)
 279                 g_free (temp);
 280         temp=NULL;
 281
 282         return cookie_list;
 283 }
 284
 285 bool util_check_valid_url ( const char *proxy )
 286 {
 287         struct in_addr proxy_addr;
 288         bool ret = TRUE;
 289
 290         return_val_if_fail ( proxy, FALSE );
 291         return_val_if_fail ( strlen(proxy), FALSE );
 292
 293        if ( inet_aton(proxy, &proxy_addr) != 0 )
 294         {
 295                 debug_warning("invalid proxy is set. \n");
 296                 ret = FALSE;
 297         }
 298
 299         return ret;
 300 }
 301
 302 /* check the given path is indicating sdp file */
 303 bool
 304 util_is_sdp_file ( const char *path )
 305 {
 306         gboolean ret = FALSE;
 307         gchar* uri = NULL;
 308
 309         debug_fenter();
 310
 311         return_val_if_fail ( path, FALSE );
 312
 313         uri = g_ascii_strdown ( path, -1 );
 314
 315         /* trimming */
 316         g_strstrip( uri );
 317
 318         /* strlen(".sdp") == 4 */
 319         if ( strlen( uri ) <= 4 )
 320         {
 321                 debug_warning ( "path is too short.\n" );
 322                 return ret;
 323         }
 324
 325         /* first, check extension name */
 326         ret = g_str_has_suffix ( uri, "sdp" );
 327
 328         /* second, if no suffix is there, check it's contents */
 329         if ( ! ret )
 330         {
 331                 /* FIXIT : do it soon */
 332                 debug_warning("determining whether it's sdp or not with it's content is not implemented yet. ;)\n");
 333         }
 334
 335         if ( uri )
 336                 g_free( uri);
 337         uri = NULL;
 338
 339         return ret;
 340 }
 341
 342 int64_t
 343 util_get_time ( void )
 344 {
 345         struct timeval tv;
 346         gettimeofday(&tv,NULL);
 347         return (int64_t)tv.tv_sec * 1000000 + tv.tv_usec;
 348 }
 349
 350 int
 351 util_get_rank_increase ( const char *factory_class )
 352 {
 353         gint rank_pri_inc = 20;
 354         gint rank_sec_inc = 10;
 355         gint ret = 0;
 356
 357         if ( g_strrstr(factory_class,"Dsp") )
 358                 ret = rank_pri_inc;
 359         else if ( g_strrstr(factory_class,"HW") )
 360                 ret = rank_pri_inc;
 361         else if ( g_strrstr(factory_class,"Arm") )
 362                 ret = rank_sec_inc;
 363
 364         return ret;
 365 }
 366
 367 int
 368 util_factory_rank_compare(GstPluginFeature *f1, GstPluginFeature *f2) // @
 369 {
 370         const gchar *klass;
 371         int f1_rank_inc=0, f2_rank_inc=0;
 372
 373         klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(f1));
 374         f1_rank_inc = util_get_rank_increase ( klass );
 375
 376         klass = gst_element_factory_get_klass(GST_ELEMENT_FACTORY(f2));
 377         f2_rank_inc = util_get_rank_increase ( klass );
 378
 379         return (gst_plugin_feature_get_rank(f2)+f2_rank_inc) - (gst_plugin_feature_get_rank(f1)+f1_rank_inc );
 380 }