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