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