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         {
  28                 SAFE_FREE(_video->media_id);
  29                 SAFE_FREE(_video->title);
  30                 SAFE_FREE(_video->album);
  31                 SAFE_FREE(_video->artist);
  32                 SAFE_FREE(_video->album_artist);
  33                 SAFE_FREE(_video->genre);
  34                 SAFE_FREE(_video->composer);
  35                 SAFE_FREE(_video->year);
  36                 SAFE_FREE(_video->recorded_date);
  37                 SAFE_FREE(_video->copyright);
  38                 SAFE_FREE(_video->track_num);
  39                 SAFE_FREE(_video);
  40
  41                 SAFE_FREE(_video);
  42                 ret = MEDIA_CONTENT_ERROR_NONE;
  43         }
  44         else
  45         {
  46                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
  47                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
  48         }
  49
  50         return ret;
  51 }
  52
  53 int video_meta_clone(video_meta_h *dst, video_meta_h src)
  54 {
  55         int ret = MEDIA_CONTENT_ERROR_NONE;
  56         video_meta_s *_src = (video_meta_s*)src;
  57
  58         if(_src != NULL)
  59         {
  60                 video_meta_s *_dst = (video_meta_s*)calloc(1, sizeof(video_meta_s));
  61
  62                 if(_dst == NULL)
  63                 {
  64
  65                         media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  66                         return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  67                 }
  68
  69                 if(STRING_VALID(_src->media_id))
  70                 {
  71                         _dst->media_id = strdup(_src->media_id);
  72                         if(_dst->media_id == NULL)
  73                         {
  74                                 video_meta_destroy((video_meta_h)_dst);
  75                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  76                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  77                         }
  78                 }
  79
  80                 if(STRING_VALID(_src->title))
  81                 {
  82                         _dst->title = strdup(_src->title);
  83                         if(_dst->title == NULL)
  84                         {
  85                                 video_meta_destroy((video_meta_h)_dst);
  86                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  87                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  88                         }
  89                 }
  90
  91                 if(STRING_VALID(_src->album))
  92                 {
  93                         _dst->album = strdup(_src->album);
  94                         if(_dst->album == NULL)
  95                         {
  96                                 video_meta_destroy((video_meta_h)_dst);
  97                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
  98                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
  99                         }
 100                 }
 101
 102                 if(STRING_VALID(_src->artist))
 103                 {
 104                         _dst->artist = strdup(_src->artist);
 105                         if(_dst->artist == NULL)
 106                         {
 107                                 video_meta_destroy((video_meta_h)_dst);
 108                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 109                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 110                         }
 111                 }
 112
 113                 if(STRING_VALID(_src->album_artist))
 114                 {
 115                         _dst->album_artist = strdup(_src->album_artist);
 116                         if(_dst->album_artist == NULL)
 117                         {
 118                                 video_meta_destroy((video_meta_h)_dst);
 119                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 120                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 121                         }
 122                 }
 123
 124                 if(STRING_VALID(_src->genre))
 125                 {
 126                         _dst->genre = strdup(_src->genre);
 127                         if(_dst->genre == NULL)
 128                         {
 129                                 video_meta_destroy((video_meta_h)_dst);
 130                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 131                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 132                         }
 133                 }
 134
 135                 if(STRING_VALID(_src->composer))
 136                 {
 137                         _dst->composer = strdup(_src->composer);
 138                         if(_dst->composer == NULL)
 139                         {
 140                                 video_meta_destroy((video_meta_h)_dst);
 141                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 142                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 143                         }
 144                 }
 145
 146                 if(STRING_VALID(_src->year))
 147                 {
 148                         _dst->year = strdup(_src->year);
 149                         if(_dst->year == NULL)
 150                         {
 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                 if(STRING_VALID(_src->recorded_date))
 158                 {
 159                         _dst->recorded_date = strdup(_src->recorded_date);
 160                         if(_dst->recorded_date == NULL)
 161                         {
 162                                 video_meta_destroy((video_meta_h)_dst);
 163                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 164                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 165                         }
 166                 }
 167
 168                 if(STRING_VALID(_src->copyright))
 169                 {
 170                         _dst->copyright = strdup(_src->copyright);
 171                         if(_dst->copyright == NULL)
 172                         {
 173                                 video_meta_destroy((video_meta_h)_dst);
 174                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 175                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 176                         }
 177                 }
 178
 179                 if(STRING_VALID(_src->track_num))
 180                 {
 181                         _dst->track_num = strdup(_src->track_num);
 182                         if(_dst->track_num == NULL)
 183                         {
 184                                 video_meta_destroy((video_meta_h)_dst);
 185                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 186                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 187                         }
 188                 }
 189
 190                 _dst->bitrate = _src->bitrate;
 191                 _dst->duration = _src->duration;
 192                 _dst->width = _src->width;
 193                 _dst->height = _src->height;
 194                 _dst->played_count = _src->played_count;
 195                 _dst->played_time = _src->played_time;
 196                 _dst->played_position = _src->played_position;
 197
 198                 *dst = (video_meta_h)_dst;
 199
 200                 ret = MEDIA_CONTENT_ERROR_NONE;
 201         }
 202         else
 203         {
 204                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 205                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 206         }
 207
 208         return ret;
 209 }
 210
 211 int video_meta_get_media_id(video_meta_h video, char **media_id)
 212 {
 213         int ret = MEDIA_CONTENT_ERROR_NONE;
 214         video_meta_s *_video = (video_meta_s*)video;
 215         if(_video)
 216         {
 217                 if(STRING_VALID(_video->media_id))
 218                 {
 219                         char *new_string = strdup(_video->media_id);
 220                         if(NULL == new_string)
 221                         {
 222                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 223                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 224                         }
 225                         *media_id = new_string;
 226                 }
 227                 else
 228                 {
 229                         *media_id = NULL;
 230                 }
 231                 ret = MEDIA_CONTENT_ERROR_NONE;
 232
 233         }
 234         else
 235         {
 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(video_meta_h video, char **album)
 244 {
 245         int ret = MEDIA_CONTENT_ERROR_NONE;
 246         video_meta_s *_video = (video_meta_s*)video;
 247         if(_video)
 248         {
 249                 if(STRING_VALID(_video->album))
 250                 {
 251                         char *new_string = strdup(_video->album);
 252                         if(NULL == new_string)
 253                         {
 254                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 255                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 256                         }
 257                         *album = new_string;
 258                 }
 259                 else
 260                 {
 261                         *album = NULL;
 262                 }
 263                 ret = MEDIA_CONTENT_ERROR_NONE;
 264
 265         }
 266         else
 267         {
 268                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 269                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 270         }
 271
 272         return ret;
 273
 274 }
 275 int video_meta_get_artist(video_meta_h video, char **artist)
 276 {
 277         int ret = MEDIA_CONTENT_ERROR_NONE;
 278         video_meta_s *_video = (video_meta_s*)video;
 279         if(_video)
 280         {
 281                 if(STRING_VALID(_video->artist))
 282                 {
 283                         char *new_string = strdup(_video->artist);
 284                         if(NULL == new_string)
 285                         {
 286                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 287                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 288                         }
 289                         *artist = new_string;
 290                 }
 291                 else
 292                 {
 293                         *artist = NULL;
 294                 }
 295                 ret = MEDIA_CONTENT_ERROR_NONE;
 296
 297         }
 298         else
 299         {
 300                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 301                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 302         }
 303
 304         return ret;
 305
 306 }
 307
 308 int video_meta_get_album_artist(video_meta_h video, char **album_artist)
 309 {
 310         int ret = MEDIA_CONTENT_ERROR_NONE;
 311         video_meta_s *_video = (video_meta_s*)video;
 312         if(_video)
 313         {
 314                 if(STRING_VALID(_video->album_artist))
 315                 {
 316                         char *new_string = strdup(_video->album_artist);
 317                         if(NULL == new_string)
 318                         {
 319                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 320                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 321                         }
 322                         *album_artist = new_string;
 323                 }
 324                 else
 325                 {
 326                         *album_artist = NULL;
 327                 }
 328                 ret = MEDIA_CONTENT_ERROR_NONE;
 329
 330         }
 331         else
 332         {
 333                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 334                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 335         }
 336
 337         return ret;
 338
 339 }
 340
 341 int video_meta_get_genre(video_meta_h video, char **genre)
 342 {
 343         int ret = MEDIA_CONTENT_ERROR_NONE;
 344         video_meta_s *_video = (video_meta_s*)video;
 345         if(_video)
 346         {
 347                 if(STRING_VALID(_video->genre))
 348                 {
 349                         char *new_string = strdup(_video->genre);
 350                         if(NULL == new_string)
 351                         {
 352                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 353                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 354                         }
 355                         *genre = new_string;
 356                 }
 357                 else
 358                 {
 359                         *genre = NULL;
 360                 }
 361
 362                 ret = MEDIA_CONTENT_ERROR_NONE;
 363         }
 364         else
 365         {
 366                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 367                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 368         }
 369
 370         return ret;
 371 }
 372
 373 int video_meta_get_composer(video_meta_h video, char **composer)
 374 {
 375         int ret = MEDIA_CONTENT_ERROR_NONE;
 376         video_meta_s *_video = (video_meta_s*)video;
 377         if(_video)
 378         {
 379                 if(STRING_VALID(_video->composer))
 380                 {
 381                         char *new_string = strdup(_video->composer);
 382                         if(NULL == new_string)
 383                         {
 384                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 385                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 386                         }
 387                         *composer = new_string;
 388                 }
 389                 else
 390                 {
 391                         *composer = NULL;
 392                 }
 393
 394                 ret = MEDIA_CONTENT_ERROR_NONE;
 395         }
 396         else
 397         {
 398                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 399                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 400         }
 401
 402         return ret;
 403 }
 404
 405 int video_meta_get_year(video_meta_h video, char **year)
 406 {
 407         int ret = MEDIA_CONTENT_ERROR_NONE;
 408         video_meta_s *_video = (video_meta_s*)video;
 409         if(_video)
 410         {
 411                 if(STRING_VALID(_video->year))
 412                 {
 413                         char *new_string = strdup(_video->year);
 414                         if(NULL == new_string)
 415                         {
 416                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 417                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 418                         }
 419                         *year = new_string;
 420                 }
 421                 else
 422                 {
 423                         *year = NULL;
 424                 }
 425
 426                 ret = MEDIA_CONTENT_ERROR_NONE;
 427         }
 428         else
 429         {
 430                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 431                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 432         }
 433
 434         return ret;
 435 }
 436
 437 int video_meta_get_recorded_date(video_meta_h video, char **recorded_date)
 438 {
 439         int ret = MEDIA_CONTENT_ERROR_NONE;
 440         video_meta_s *_video = (video_meta_s*)video;
 441         if(_video)
 442         {
 443                 if(STRING_VALID(_video->recorded_date))
 444                 {
 445                         char *new_string = strdup(_video->recorded_date);
 446                         if(NULL == new_string)
 447                         {
 448                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 449                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 450                         }
 451                         *recorded_date = new_string;
 452                 }
 453                 else
 454                 {
 455                         *recorded_date = NULL;
 456                 }
 457
 458                 ret = MEDIA_CONTENT_ERROR_NONE;
 459         }
 460         else
 461         {
 462                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 463                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 464         }
 465
 466         return ret;
 467 }
 468
 469 int video_meta_get_copyright(video_meta_h video, char **copyright)
 470 {
 471         int ret = MEDIA_CONTENT_ERROR_NONE;
 472         video_meta_s *_video = (video_meta_s*)video;
 473         if(_video)
 474         {
 475                 if(STRING_VALID(_video->copyright))
 476                 {
 477                         char *new_string = strdup(_video->copyright);
 478                         if(NULL == new_string)
 479                         {
 480                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 481                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 482                         }
 483                         *copyright = new_string;
 484                 }
 485                 else
 486                 {
 487                         *copyright = NULL;
 488                 }
 489
 490                 ret = MEDIA_CONTENT_ERROR_NONE;
 491         }
 492         else
 493         {
 494                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 495                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 496         }
 497
 498         return ret;
 499 }
 500
 501 int video_meta_get_track_num(video_meta_h video, char **track_num)
 502 {
 503         int ret = MEDIA_CONTENT_ERROR_NONE;
 504         video_meta_s *_video = (video_meta_s*)video;
 505         if(_video)
 506         {
 507                 if(STRING_VALID(_video->track_num))
 508                 {
 509                         char *new_string = strdup(_video->track_num);
 510                         if(NULL == new_string)
 511                         {
 512                                 media_content_error("OUT_OF_MEMORY(0x%08x)", MEDIA_CONTENT_ERROR_OUT_OF_MEMORY);
 513                                 return MEDIA_CONTENT_ERROR_OUT_OF_MEMORY;
 514                         }
 515                         *track_num = new_string;
 516                 }
 517                 else
 518                 {
 519                         *track_num = NULL;
 520                 }
 521
 522                 ret = MEDIA_CONTENT_ERROR_NONE;
 523         }
 524         else
 525         {
 526                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 527                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 528         }
 529
 530         return ret;
 531 }
 532
 533 int video_meta_get_bit_rate(video_meta_h video, int *bit_rate)
 534 {
 535         int ret = MEDIA_CONTENT_ERROR_NONE;
 536         video_meta_s *_video = (video_meta_s*)video;
 537
 538         if(_video && bit_rate)
 539         {
 540                 *bit_rate = _video->bitrate;
 541                 ret = MEDIA_CONTENT_ERROR_NONE;
 542         }
 543         else
 544         {
 545                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 546                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 547         }
 548
 549         return ret;
 550 }
 551
 552 int video_meta_get_duration(video_meta_h video, int *duration)
 553 {
 554         int ret = MEDIA_CONTENT_ERROR_NONE;
 555         video_meta_s *_video = (video_meta_s*)video;
 556
 557         if(_video && duration)
 558         {
 559                 *duration = _video->duration;
 560                 ret = MEDIA_CONTENT_ERROR_NONE;
 561         }
 562         else
 563         {
 564                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 565                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 566         }
 567
 568         return ret;
 569 }
 570
 571 int video_meta_get_width(video_meta_h video, int *width)
 572 {
 573         int ret = MEDIA_CONTENT_ERROR_NONE;
 574         video_meta_s *_video = (video_meta_s*)video;
 575
 576         if(_video && width)
 577         {
 578                 *width = _video->width;
 579                 ret = MEDIA_CONTENT_ERROR_NONE;
 580         }
 581         else
 582         {
 583                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 584                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 585         }
 586
 587         return ret;
 588 }
 589
 590 int video_meta_get_height(video_meta_h video, int *height)
 591 {
 592         int ret = MEDIA_CONTENT_ERROR_NONE;
 593         video_meta_s *_video = (video_meta_s*)video;
 594         if(_video && height)
 595         {
 596                 *height = _video->height;
 597                 ret = MEDIA_CONTENT_ERROR_NONE;
 598         }
 599         else
 600         {
 601                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 602                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 603         }
 604
 605         return ret;
 606 }
 607
 608 int video_meta_get_played_count(video_meta_h video, int *played_count)
 609 {
 610         int ret = MEDIA_CONTENT_ERROR_NONE;
 611         video_meta_s *_video = (video_meta_s*)video;
 612
 613         if(_video && played_count)
 614         {
 615                 *played_count = _video->played_count;
 616                 ret = MEDIA_CONTENT_ERROR_NONE;
 617         }
 618         else
 619         {
 620                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 621                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 622         }
 623
 624         return ret;
 625 }
 626
 627 int video_meta_get_played_time(video_meta_h video, time_t* played_time)
 628 {
 629         int ret = MEDIA_CONTENT_ERROR_NONE;
 630         video_meta_s *_video = (video_meta_s*)video;
 631
 632         if(_video)
 633         {
 634                 *played_time = _video->played_time;
 635                 ret = MEDIA_CONTENT_ERROR_NONE;
 636         }
 637         else
 638         {
 639                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 640                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 641         }
 642
 643         return ret;
 644 }
 645
 646 int video_meta_get_played_position(video_meta_h video, int *played_position)
 647 {
 648         int ret = MEDIA_CONTENT_ERROR_NONE;
 649         video_meta_s *_video = (video_meta_s*)video;
 650
 651         if(_video)
 652         {
 653                 *played_position = _video->played_position;
 654                 ret = MEDIA_CONTENT_ERROR_NONE;
 655         }
 656         else
 657         {
 658                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 659                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 660         }
 661
 662         return ret;
 663 }
 664
 665 int video_meta_set_played_count(video_meta_h video, int played_count)
 666 {
 667         int ret = MEDIA_CONTENT_ERROR_NONE;
 668         video_meta_s *_video = (video_meta_s*)video;
 669
 670         if(_video != NULL)
 671         {
 672                 _video->played_count = played_count;
 673         }
 674         else
 675         {
 676                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 677                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 678         }
 679
 680         return ret;
 681 }
 682
 683 int video_meta_set_played_time(video_meta_h video, time_t played_time)
 684 {
 685         int ret = MEDIA_CONTENT_ERROR_NONE;
 686         video_meta_s *_video = (video_meta_s*)video;
 687
 688         if(_video != NULL)
 689         {
 690                 _video->played_time = played_time;
 691         }
 692         else
 693         {
 694                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 695                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 696         }
 697
 698         return ret;
 699 }
 700
 701 int video_meta_set_played_position(video_meta_h video, int played_position)
 702 {
 703         int ret = MEDIA_CONTENT_ERROR_NONE;
 704         video_meta_s *_video = (video_meta_s*)video;
 705
 706         if(_video != NULL)
 707         {
 708                 _video->played_position = played_position;
 709         }
 710         else
 711         {
 712                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 713                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 714         }
 715
 716         return ret;
 717 }
 718
 719 int video_meta_update_to_db(video_meta_h video)
 720 {
 721         int ret = MEDIA_CONTENT_ERROR_NONE;
 722         video_meta_s *_video = (video_meta_s*)video;
 723         char *sql = NULL;
 724
 725         if(_video != NULL && STRING_VALID(_video->media_id))
 726         {
 727                 char storage_id[MEDIA_CONTENT_UUID_SIZE+1] = {0,};
 728                 memset(storage_id, 0x00, sizeof(storage_id));
 729
 730                 ret = _media_db_get_storage_id_by_media_id(_video->media_id, storage_id);
 731                 media_content_retv_if(ret != MEDIA_CONTENT_ERROR_NONE, ret);
 732
 733                 sql = sqlite3_mprintf(UPDATE_AV_META_FROM_MEDIA, storage_id, _video->played_count, _video->played_time, _video->played_position, _video->media_id);
 734                 ret = _content_query_sql(sql);
 735                 sqlite3_free(sql);
 736         }
 737         else
 738         {
 739                 media_content_error("INVALID_PARAMETER(0x%08x)", MEDIA_CONTENT_ERROR_INVALID_PARAMETER);
 740                 ret = MEDIA_CONTENT_ERROR_INVALID_PARAMETER;
 741         }
 742
 743         return ret;
 744 }