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->played_count = _src->played_count;
 162                 _dst->played_time = _src->played_time;
 163                 _dst->played_position = _src->played_position;
 164                 _dst->rotation = _src->rotation;
 165
 166                 *dst = (video_meta_h)_dst;
 167
 168                 ret = MEDIA_CONTENT_ERROR_NONE;
 169         } else {
 170                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 171                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 172         }
 173
 174         return ret;
 175 }
 176
 177 int video_meta_get_media_id(video_meta_h video, char **media_id)
 178 {
 179         int ret = MEDIA_CONTENT_ERROR_NONE;
 180         video_meta_s *_video = (video_meta_s*)video;
 181         if (_video) {
 182                 if (_video->media_id != NULL) {
 183                         char *new_string = strdup(_video->media_id);
 184                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 185
 186                         *media_id = new_string;
 187                 } else {
 188                         *media_id = NULL;
 189                 }
 190                 ret = MEDIA_CONTENT_ERROR_NONE;
 191
 192         } else {
 193                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 194                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 195         }
 196
 197         return ret;
 198 }
 199
 200 int video_meta_get_album(video_meta_h video, char **album)
 201 {
 202         int ret = MEDIA_CONTENT_ERROR_NONE;
 203         video_meta_s *_video = (video_meta_s*)video;
 204         if (_video) {
 205                 if (_video->album != NULL) {
 206                         char *new_string = strdup(_video->album);
 207                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 208
 209                         *album = new_string;
 210                 } else {
 211                         *album = NULL;
 212                 }
 213                 ret = MEDIA_CONTENT_ERROR_NONE;
 214
 215         } else {
 216                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 217                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 218         }
 219
 220         return ret;
 221 }
 222
 223 int video_meta_get_artist(video_meta_h video, char **artist)
 224 {
 225         int ret = MEDIA_CONTENT_ERROR_NONE;
 226         video_meta_s *_video = (video_meta_s*)video;
 227         if (_video) {
 228                 if (_video->artist != NULL) {
 229                         char *new_string = strdup(_video->artist);
 230                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 231
 232                         *artist = new_string;
 233                 } else {
 234                         *artist = NULL;
 235                 }
 236                 ret = MEDIA_CONTENT_ERROR_NONE;
 237
 238         } else {
 239                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 240                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 241         }
 242
 243         return ret;
 244 }
 245
 246 int video_meta_get_album_artist(video_meta_h video, char **album_artist)
 247 {
 248         int ret = MEDIA_CONTENT_ERROR_NONE;
 249         video_meta_s *_video = (video_meta_s*)video;
 250         if (_video) {
 251                 if (_video->album_artist != NULL) {
 252                         char *new_string = strdup(_video->album_artist);
 253                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 254
 255                         *album_artist = new_string;
 256                 } else {
 257                         *album_artist = NULL;
 258                 }
 259                 ret = MEDIA_CONTENT_ERROR_NONE;
 260
 261         } else {
 262                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 263                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 264         }
 265
 266         return ret;
 267 }
 268
 269 int video_meta_get_genre(video_meta_h video, char **genre)
 270 {
 271         int ret = MEDIA_CONTENT_ERROR_NONE;
 272         video_meta_s *_video = (video_meta_s*)video;
 273         if (_video) {
 274                 if (_video->genre != NULL) {
 275                         char *new_string = strdup(_video->genre);
 276                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 277
 278                         *genre = new_string;
 279                 } else {
 280                         *genre = NULL;
 281                 }
 282
 283                 ret = MEDIA_CONTENT_ERROR_NONE;
 284         } else {
 285                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 286                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 287         }
 288
 289         return ret;
 290 }
 291
 292 int video_meta_get_composer(video_meta_h video, char **composer)
 293 {
 294         int ret = MEDIA_CONTENT_ERROR_NONE;
 295         video_meta_s *_video = (video_meta_s*)video;
 296         if (_video) {
 297                 if (_video->composer != NULL) {
 298                         char *new_string = strdup(_video->composer);
 299                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 300
 301                         *composer = new_string;
 302                 } else {
 303                         *composer = NULL;
 304                 }
 305
 306                 ret = MEDIA_CONTENT_ERROR_NONE;
 307         } else {
 308                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 309                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 310         }
 311
 312         return ret;
 313 }
 314
 315 int video_meta_get_year(video_meta_h video, char **year)
 316 {
 317         int ret = MEDIA_CONTENT_ERROR_NONE;
 318         video_meta_s *_video = (video_meta_s*)video;
 319         if (_video) {
 320                 if (_video->year != NULL) {
 321                         char *new_string = strdup(_video->year);
 322                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 323
 324                         *year = new_string;
 325                 } else {
 326                         *year = NULL;
 327                 }
 328
 329                 ret = MEDIA_CONTENT_ERROR_NONE;
 330         } else {
 331                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 332                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 333         }
 334
 335         return ret;
 336 }
 337
 338 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 339 {
 340         int ret = MEDIA_CONTENT_ERROR_NONE;
 341         video_meta_s *_video = (video_meta_s*)video;
 342         if (_video) {
 343                 if (_video->recorded_date != NULL) {
 344                         char *new_string = strdup(_video->recorded_date);
 345                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 346
 347                         *recorded_date = new_string;
 348                 } else {
 349                         *recorded_date = NULL;
 350                 }
 351
 352                 ret = MEDIA_CONTENT_ERROR_NONE;
 353         } else {
 354                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 355                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 356         }
 357
 358         return ret;
 359 }
 360
 361 int video_meta_get_copyright(video_meta_h video, char **copyright)
 362 {
 363         int ret = MEDIA_CONTENT_ERROR_NONE;
 364         video_meta_s *_video = (video_meta_s*)video;
 365         if (_video) {
 366                 if (_video->copyright != NULL) {
 367                         char *new_string = strdup(_video->copyright);
 368                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 369
 370                         *copyright = new_string;
 371                 } else {
 372                         *copyright = NULL;
 373                 }
 374
 375                 ret = MEDIA_CONTENT_ERROR_NONE;
 376         } else {
 377                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 378                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 379         }
 380
 381         return ret;
 382 }
 383
 384 int video_meta_get_track_num(video_meta_h video, char **track_num)
 385 {
 386         int ret = MEDIA_CONTENT_ERROR_NONE;
 387         video_meta_s *_video = (video_meta_s*)video;
 388         if (_video) {
 389                 if (_video->track_num != NULL) {
 390                         char *new_string = strdup(_video->track_num);
 391                         media_content_retvm_if(new_string == NULL, MEDIA_CONTENT_ERROR_OUT_OF_MEMORY, "OUT_OF_MEMORY");
 392
 393                         *track_num = new_string;
 394                 } else {
 395                         *track_num = NULL;
 396                 }
 397
 398                 ret = MEDIA_CONTENT_ERROR_NONE;
 399         } else {
 400                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 401                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 402         }
 403
 404         return ret;
 405 }
 406
 407 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 408 {
 409         int ret = MEDIA_CONTENT_ERROR_NONE;
 410         video_meta_s *_video = (video_meta_s*)video;
 411
 412         if (_video && bit_rate) {
 413                 *bit_rate = _video->bitrate;
 414                 ret = MEDIA_CONTENT_ERROR_NONE;
 415         } else {
 416                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 417                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 418         }
 419
 420         return ret;
 421 }
 422
 423 int video_meta_get_duration(video_meta_h video, int *duration)
 424 {
 425         int ret = MEDIA_CONTENT_ERROR_NONE;
 426         video_meta_s *_video = (video_meta_s*)video;
 427
 428         if (_video && duration) {
 429                 *duration = _video->duration;
 430                 ret = MEDIA_CONTENT_ERROR_NONE;
 431         } else {
 432                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 433                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 434         }
 435
 436         return ret;
 437 }
 438
 439 int video_meta_get_width(video_meta_h video, int *width)
 440 {
 441         int ret = MEDIA_CONTENT_ERROR_NONE;
 442         video_meta_s *_video = (video_meta_s*)video;
 443
 444         if (_video && width) {
 445                 *width = _video->width;
 446                 ret = MEDIA_CONTENT_ERROR_NONE;
 447         } else {
 448                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 449                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 450         }
 451
 452         return ret;
 453 }
 454
 455 int video_meta_get_height(video_meta_h video, int *height)
 456 {
 457         int ret = MEDIA_CONTENT_ERROR_NONE;
 458         video_meta_s *_video = (video_meta_s*)video;
 459         if (_video && height) {
 460                 *height = _video->height;
 461                 ret = MEDIA_CONTENT_ERROR_NONE;
 462         } else {
 463                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 464                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 465         }
 466
 467         return ret;
 468 }
 469
 470 int video_meta_get_rotation(video_meta_h video, int *rotation)
 471 {
 472         int ret = MEDIA_CONTENT_ERROR_NONE;
 473         video_meta_s *_video = (video_meta_s*)video;
 474         if (_video && rotation) {
 475                 *rotation = _video->rotation;
 476                 ret = MEDIA_CONTENT_ERROR_NONE;
 477         } else {
 478                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 479                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 480         }
 481
 482         return ret;
 483 }
 484
 485
 486 int video_meta_get_played_count(video_meta_h video, int *played_count)
 487 {
 488         int ret = MEDIA_CONTENT_ERROR_NONE;
 489         video_meta_s *_video = (video_meta_s*)video;
 490
 491         if (_video && played_count) {
 492                 *played_count = _video->played_count;
 493                 ret = MEDIA_CONTENT_ERROR_NONE;
 494         } else {
 495                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 496                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 497         }
 498
 499         return ret;
 500 }
 501
 502 int video_meta_get_played_time(video_meta_h video, time_t* played_time)
 503 {
 504         int ret = MEDIA_CONTENT_ERROR_NONE;
 505         video_meta_s *_video = (video_meta_s*)video;
 506
 507         if (_video) {
 508                 *played_time = _video->played_time;
 509                 ret = MEDIA_CONTENT_ERROR_NONE;
 510         } else {
 511                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 512                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 513         }
 514
 515         return ret;
 516 }
 517
 518 int video_meta_get_played_position(video_meta_h video, int *played_position)
 519 {
 520         int ret = MEDIA_CONTENT_ERROR_NONE;
 521         video_meta_s *_video = (video_meta_s*)video;
 522
 523         if (_video) {
 524                 *played_position = _video->played_position;
 525                 ret = MEDIA_CONTENT_ERROR_NONE;
 526         } else {
 527                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 528                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 529         }
 530
 531         return ret;
 532 }
 533
 534 int video_meta_set_played_count(video_meta_h video, int played_count)
 535 {
 536         int ret = MEDIA_CONTENT_ERROR_NONE;
 537         video_meta_s *_video = (video_meta_s*)video;
 538
 539         if ((_video != NULL) && (played_count >= 0)) {
 540                 _video->played_count = played_count;
 541         } else {
 542                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 543                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 544         }
 545
 546         return ret;
 547 }
 548
 549 int video_meta_set_played_time(video_meta_h video, time_t played_time)
 550 {
 551         int ret = MEDIA_CONTENT_ERROR_NONE;
 552         video_meta_s *_video = (video_meta_s*)video;
 553
 554         if ((_video != NULL) && (played_time >= 0)) {
 555                 _video->played_time = played_time;
 556         } else {
 557                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 558                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 559         }
 560
 561         return ret;
 562 }
 563
 564 int video_meta_set_played_position(video_meta_h video, int played_position)
 565 {
 566         int ret = MEDIA_CONTENT_ERROR_NONE;
 567         video_meta_s *_video = (video_meta_s*)video;
 568
 569         if ((_video != NULL) && (played_position >= 0)) {
 570                 _video->played_position = played_position;
 571         } else {
 572                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 573                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 574         }
 575
 576         return ret;
 577 }
 578
 579 int video_meta_update_to_db(video_meta_h video)
 580 {
 581         int ret = MEDIA_CONTENT_ERROR_NONE;
 582         video_meta_s *_video = (video_meta_s*)video;
 583         char *sql = NULL;
 584
 585         if (_video != NULL && STRING_VALID(_video->media_id)) {
 586                 char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0, };
 587                 memset(storage_id, 0x00, sizeof(storage_id));
 588
 589                 ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
 590                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 591
 592                 sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
 593                 ret = _content_query_sql(sql);
 594                 SQLITE3_SAFE_FREE(sql);
 595         } else {
 596                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 597                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 598         }
 599
 600         return ret;
 601 }