src/media_video.c

   1 /*
   2 * Copyright (c) 2011 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 #include <media_info_private.h>
  19
  20 #define media_content_retv_free_video_if(expr, val, p_str) do { \
  21                                 if (expr) {     \
  22                                         LOGE(FONT_COLOR_RED"Memory allocation failure"FONT_COLOR_RESET);        \
  23                                         video_meta_destroy(p_str);      \
  24                                         return (val);   \
  25                                 }       \
  26                         } while (0)
  27
  28
  29 int video_meta_destroy(video_meta_h video)
  30 {
  31         video_meta_s *_video = (video_meta_s*)video;
  32         media_content_retvm_if(_video == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Video handle is null");
  33
  34         SAFE_FREE(_video->media_id);
  35         SAFE_FREE(_video->album);
  36         SAFE_FREE(_video->artist);
  37         SAFE_FREE(_video->album_artist);
  38         SAFE_FREE(_video->genre);
  39         SAFE_FREE(_video->composer);
  40         SAFE_FREE(_video->year);
  41         SAFE_FREE(_video->recorded_date);
  42         SAFE_FREE(_video->copyright);
  43         SAFE_FREE(_video->track_num);
  44         SAFE_FREE(_video);
  45
  46         return MEDIA_CONTENT_ERROR_NONE;
  47 }
  48
  49 int video_meta_clone(video_meta_h *dst, video_meta_h src)
  50 {
  51         video_meta_s *_src = (video_meta_s*)src;
  52         media_content_retvm_if(_src == NULL, MEDIA_CONTENT_ERROR_INVALID_PARAMETER, "Source handle is null");
  53
  54         video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_s));
  55         media_content_retvm_if(_dst == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
  56
  57         if (_src->media_id != NULL) {
  58                 _dst->media_id = g_strdup(_src->media_id);
  59                 media_content_retv_free_video_if(_dst->media_id == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  60         }
  61
  62         if (_src->album != NULL) {
  63                 _dst->album = g_strdup(_src->album);
  64                 media_content_retv_free_video_if(_dst->album == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  65         }
  66
  67         if (_src->artist != NULL) {
  68                 _dst->artist = g_strdup(_src->artist);
  69                 media_content_retv_free_video_if(_dst->artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  70         }
  71
  72         if (_src->album_artist != NULL) {
  73                 _dst->album_artist = g_strdup(_src->album_artist);
  74                 media_content_retv_free_video_if(_dst->album_artist == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  75         }
  76
  77         if (_src->genre != NULL) {
  78                 _dst->genre = g_strdup(_src->genre);
  79                 media_content_retv_free_video_if(_dst->genre == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  80         }
  81
  82         if (_src->composer != NULL) {
  83                 _dst->composer = g_strdup(_src->composer);
  84                 media_content_retv_free_video_if(_dst->composer == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  85         }
  86
  87         if (_src->year != NULL) {
  88                 _dst->year = g_strdup(_src->year);
  89                 media_content_retv_free_video_if(_dst->year == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  90         }
  91
  92         if (_src->recorded_date != NULL) {
  93                 _dst->recorded_date = g_strdup(_src->recorded_date);
  94                 media_content_retv_free_video_if(_dst->recorded_date == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
  95         }
  96
  97         if (_src->copyright != NULL) {
  98                 _dst->copyright = g_strdup(_src->copyright);
  99                 media_content_retv_free_video_if(_dst->copyright == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
 100         }
 101
 102         if (_src->track_num != NULL) {
 103                 _dst->track_num = g_strdup(_src->track_num);
 104                 media_content_retv_free_video_if(_dst->track_num == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, (video_meta_h)_dst);
 105         }
 106
 107         _dst->bitrate = _src->bitrate;
 108         _dst->duration = _src->duration;
 109         _dst->width = _src->width;
 110         _dst->height = _src->height;
 111         _dst->rotation = _src->rotation;
 112
 113         *dst = (video_meta_h)_dst;
 114
 115         return MEDIA_CONTENT_ERROR_NONE;
 116 }
 117
 118 int video_meta_get_media_id(video_meta_h video, char **media_id)
 119 {
 120         int ret = MEDIA_CONTENT_ERROR_NONE;
 121         video_meta_s *_video = (video_meta_s*)video;
 122         if (_video) {
 123                 if (_video->media_id != NULL) {
 124                         char *new_string = strdup(_video->media_id);
 125                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 126
 127                         *media_id = new_string;
 128                 } else {
 129                         *media_id = NULL;
 130                 }
 131                 ret = MEDIA_CONTENT_ERROR_NONE;
 132
 133         } else {
 134                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 135                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 136         }
 137
 138         return ret;
 139 }
 140
 141 int video_meta_get_album(video_meta_h video, char **album)
 142 {
 143         int ret = MEDIA_CONTENT_ERROR_NONE;
 144         video_meta_s *_video = (video_meta_s*)video;
 145         if (_video) {
 146                 if (_video->album != NULL) {
 147                         char *new_string = strdup(_video->album);
 148                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 149
 150                         *album = new_string;
 151                 } else {
 152                         *album = NULL;
 153                 }
 154                 ret = MEDIA_CONTENT_ERROR_NONE;
 155
 156         } else {
 157                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 158                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 159         }
 160
 161         return ret;
 162 }
 163
 164 int video_meta_get_artist(video_meta_h video, char **artist)
 165 {
 166         int ret = MEDIA_CONTENT_ERROR_NONE;
 167         video_meta_s *_video = (video_meta_s*)video;
 168         if (_video) {
 169                 if (_video->artist != NULL) {
 170                         char *new_string = strdup(_video->artist);
 171                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 172
 173                         *artist = new_string;
 174                 } else {
 175                         *artist = NULL;
 176                 }
 177                 ret = MEDIA_CONTENT_ERROR_NONE;
 178
 179         } else {
 180                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 181                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 182         }
 183
 184         return ret;
 185 }
 186
 187 int video_meta_get_album_artist(video_meta_h video, char **album_artist)
 188 {
 189         int ret = MEDIA_CONTENT_ERROR_NONE;
 190         video_meta_s *_video = (video_meta_s*)video;
 191         if (_video) {
 192                 if (_video->album_artist != NULL) {
 193                         char *new_string = strdup(_video->album_artist);
 194                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 195
 196                         *album_artist = new_string;
 197                 } else {
 198                         *album_artist = NULL;
 199                 }
 200                 ret = MEDIA_CONTENT_ERROR_NONE;
 201
 202         } else {
 203                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 204                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 205         }
 206
 207         return ret;
 208 }
 209
 210 int video_meta_get_genre(video_meta_h video, char **genre)
 211 {
 212         int ret = MEDIA_CONTENT_ERROR_NONE;
 213         video_meta_s *_video = (video_meta_s*)video;
 214         if (_video) {
 215                 if (_video->genre != NULL) {
 216                         char *new_string = strdup(_video->genre);
 217                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 218
 219                         *genre = new_string;
 220                 } else {
 221                         *genre = NULL;
 222                 }
 223
 224                 ret = MEDIA_CONTENT_ERROR_NONE;
 225         } else {
 226                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 227                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 228         }
 229
 230         return ret;
 231 }
 232
 233 int video_meta_get_composer(video_meta_h video, char **composer)
 234 {
 235         int ret = MEDIA_CONTENT_ERROR_NONE;
 236         video_meta_s *_video = (video_meta_s*)video;
 237         if (_video) {
 238                 if (_video->composer != NULL) {
 239                         char *new_string = strdup(_video->composer);
 240                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 241
 242                         *composer = new_string;
 243                 } else {
 244                         *composer = NULL;
 245                 }
 246
 247                 ret = MEDIA_CONTENT_ERROR_NONE;
 248         } else {
 249                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 250                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 251         }
 252
 253         return ret;
 254 }
 255
 256 int video_meta_get_year(video_meta_h video, char **year)
 257 {
 258         int ret = MEDIA_CONTENT_ERROR_NONE;
 259         video_meta_s *_video = (video_meta_s*)video;
 260         if (_video) {
 261                 if (_video->year != NULL) {
 262                         char *new_string = strdup(_video->year);
 263                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 264
 265                         *year = new_string;
 266                 } else {
 267                         *year = NULL;
 268                 }
 269
 270                 ret = MEDIA_CONTENT_ERROR_NONE;
 271         } else {
 272                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 273                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 274         }
 275
 276         return ret;
 277 }
 278
 279 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 280 {
 281         int ret = MEDIA_CONTENT_ERROR_NONE;
 282         video_meta_s *_video = (video_meta_s*)video;
 283         if (_video) {
 284                 if (_video->recorded_date != NULL) {
 285                         char *new_string = strdup(_video->recorded_date);
 286                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 287
 288                         *recorded_date = new_string;
 289                 } else {
 290                         *recorded_date = NULL;
 291                 }
 292
 293                 ret = MEDIA_CONTENT_ERROR_NONE;
 294         } else {
 295                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 296                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 297         }
 298
 299         return ret;
 300 }
 301
 302 int video_meta_get_copyright(video_meta_h video, char **copyright)
 303 {
 304         int ret = MEDIA_CONTENT_ERROR_NONE;
 305         video_meta_s *_video = (video_meta_s*)video;
 306         if (_video) {
 307                 if (_video->copyright != NULL) {
 308                         char *new_string = strdup(_video->copyright);
 309                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 310
 311                         *copyright = new_string;
 312                 } else {
 313                         *copyright = NULL;
 314                 }
 315
 316                 ret = MEDIA_CONTENT_ERROR_NONE;
 317         } else {
 318                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 319                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 320         }
 321
 322         return ret;
 323 }
 324
 325 int video_meta_get_track_num(video_meta_h video, char **track_num)
 326 {
 327         int ret = MEDIA_CONTENT_ERROR_NONE;
 328         video_meta_s *_video = (video_meta_s*)video;
 329         if (_video) {
 330                 if (_video->track_num != NULL) {
 331                         char *new_string = strdup(_video->track_num);
 332                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 333
 334                         *track_num = new_string;
 335                 } else {
 336                         *track_num = NULL;
 337                 }
 338
 339                 ret = MEDIA_CONTENT_ERROR_NONE;
 340         } else {
 341                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 342                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 343         }
 344
 345         return ret;
 346 }
 347
 348 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 349 {
 350         int ret = MEDIA_CONTENT_ERROR_NONE;
 351         video_meta_s *_video = (video_meta_s*)video;
 352
 353         if (_video && bit_rate) {
 354                 *bit_rate = _video->bitrate;
 355                 ret = MEDIA_CONTENT_ERROR_NONE;
 356         } else {
 357                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 358                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 359         }
 360
 361         return ret;
 362 }
 363
 364 int video_meta_get_duration(video_meta_h video, int *duration)
 365 {
 366         int ret = MEDIA_CONTENT_ERROR_NONE;
 367         video_meta_s *_video = (video_meta_s*)video;
 368
 369         if (_video && duration) {
 370                 *duration = _video->duration;
 371                 ret = MEDIA_CONTENT_ERROR_NONE;
 372         } else {
 373                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 374                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 375         }
 376
 377         return ret;
 378 }
 379
 380 int video_meta_get_width(video_meta_h video, int *width)
 381 {
 382         int ret = MEDIA_CONTENT_ERROR_NONE;
 383         video_meta_s *_video = (video_meta_s*)video;
 384
 385         if (_video && width) {
 386                 *width = _video->width;
 387                 ret = MEDIA_CONTENT_ERROR_NONE;
 388         } else {
 389                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 390                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 391         }
 392
 393         return ret;
 394 }
 395
 396 int video_meta_get_height(video_meta_h video, int *height)
 397 {
 398         int ret = MEDIA_CONTENT_ERROR_NONE;
 399         video_meta_s *_video = (video_meta_s*)video;
 400         if (_video && height) {
 401                 *height = _video->height;
 402                 ret = MEDIA_CONTENT_ERROR_NONE;
 403         } else {
 404                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 405                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 406         }
 407
 408         return ret;
 409 }
 410
 411 int video_meta_get_rotation(video_meta_h video, int *rotation)
 412 {
 413         int ret = MEDIA_CONTENT_ERROR_NONE;
 414         video_meta_s *_video = (video_meta_s*)video;
 415         if (_video && rotation) {
 416                 *rotation = _video->rotation;
 417                 ret = MEDIA_CONTENT_ERROR_NONE;
 418         } else {
 419                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 420                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 421         }
 422
 423         return ret;
 424 }