src/visual/minfo-meta.c

   1 /*
   2  * libmedia-service
   3  *
   4  * Copyright (c) 2000 - 2011 Samsung Electronics Co., Ltd. All rights reserved.
   5  *
   6  * Contact: Hyunjun Ko <zzoon.ko@samsung.com>, Haejeong Kim <backto.kim@samsung.com>
   7  *
   8  * Licensed under the Apache License, Version 2.0 (the "License");
   9  * you may not use this file except in compliance with the License.
  10  * You may obtain a copy of the License at
  11  *
  12  * http://www.apache.org/licenses/LICENSE-2.0
  13  *
  14  * Unless required by applicable law or agreed to in writing, software
  15  * distributed under the License is distributed on an "AS IS" BASIS,
  16  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  17  * See the License for the specific language governing permissions and
  18  * limitations under the License.
  19  *
  20  */
  21
  22 #include "minfo-meta.h"
  23 #include "visual-svc.h"
  24 #include "minfo-bookmark.h"
  25 #include "media-svc-api.h"
  26 #include "visual-svc-util.h"
  27 #include "visual-svc-debug.h"
  28 #include "visual-svc-error.h"
  29 #include <string.h>
  30
  31 static void _minfo_mmeta_init(Mmeta *mmeta);
  32
  33 int minfo_mmeta_load(MediaSvcHandle *mb_svc_handle, Mmeta *mmeta, mb_svc_media_record_s *p_md_record)
  34 {
  35         int ret = -1;
  36         mb_svc_media_record_s media_record = {"",};
  37         mb_svc_image_meta_record_s image_meta_record = {0,};
  38         mb_svc_video_meta_record_s video_meta_record = {0,};
  39
  40         if (p_md_record == NULL) {
  41                 ret =
  42                     mb_svc_get_media_record_by_id(mb_svc_handle, mmeta->media_uuid,
  43                                                   &media_record);
  44                 if (ret < 0) {
  45                         mb_svc_debug
  46                             ("minfo_get_meta_info:get media record by id failed\n");
  47                         return ret;
  48                 }
  49         } else {
  50                 media_record = *p_md_record;
  51         }
  52
  53         if (media_record.content_type == MINFO_ITEM_IMAGE) {
  54                 ret =
  55                     mb_svc_get_image_record_by_media_id(mb_svc_handle, mmeta->media_uuid,
  56                                                         &image_meta_record);
  57                 if (ret < 0) {
  58                         return ret;
  59                 }
  60
  61                 mmeta->longitude = image_meta_record.longitude;
  62                 mmeta->latitude = image_meta_record.latitude;
  63                 mmeta->type = media_record.content_type;
  64                 mmeta->description = NULL;
  65
  66                 mmeta->width = image_meta_record.width;
  67                 mmeta->height = image_meta_record.height;
  68                 mmeta->datetaken = image_meta_record.datetaken;
  69
  70                 mmeta->image_info = minfo_mimage_new(mb_svc_handle, NULL);
  71                 if (mmeta->image_info == NULL) {
  72                         return MB_SVC_ERROR_INTERNAL;
  73                 }
  74                 mmeta->image_info->orientation = image_meta_record.orientation;
  75         }
  76
  77         else if (media_record.content_type == MINFO_ITEM_VIDEO) {
  78                 ret =
  79                     mb_svc_get_video_record_by_media_id(mb_svc_handle, mmeta->media_uuid,
  80                                                         &video_meta_record);
  81                 if (ret < 0) {
  82                         return ret;
  83                 }
  84
  85                 mmeta->type = media_record.content_type;
  86                 mmeta->description = NULL;
  87                 mmeta->longitude = video_meta_record.longitude;
  88                 mmeta->latitude = video_meta_record.latitude;
  89
  90                 mmeta->width = video_meta_record.width;
  91                 mmeta->height = video_meta_record.height;
  92                 mmeta->datetaken = video_meta_record.datetaken;
  93
  94                 mmeta->video_info = minfo_mvideo_new(mb_svc_handle, mmeta->media_uuid);
  95
  96                 if (mmeta->video_info == NULL) {
  97                         return MB_SVC_ERROR_INTERNAL;
  98                 }
  99         }
 100
 101         return 0;
 102 }
 103
 104 static void _minfo_mmeta_init(Mmeta *mmeta)
 105 {
 106         mmeta->gtype = MINFO_TYPE_MMETA;
 107
 108         mmeta->media_uuid = NULL;
 109         mmeta->type = 0;
 110         mmeta->description = NULL;
 111         mmeta->image_info = NULL;
 112         mmeta->video_info = NULL;
 113         mmeta->_reserved = NULL;
 114         mmeta->longitude = 0.0f;
 115         mmeta->latitude = 0.0f;
 116 }
 117
 118 Mmeta *minfo_mmeta_new(MediaSvcHandle *mb_svc_handle, const char *media_uuid, mb_svc_media_record_s *p_md_record)
 119 {
 120         Mmeta *mmeta = NULL;
 121         int ret = 0;
 122
 123         mmeta = (Mmeta *) malloc(sizeof(Mmeta));
 124         if (mmeta == NULL) {
 125                 return NULL;
 126         }
 127
 128         _minfo_mmeta_init(mmeta);
 129
 130         mmeta->media_uuid = (char *)malloc(MB_SVC_UUID_LEN_MAX + 1);
 131
 132         if (p_md_record) {
 133                 strncpy(mmeta->media_uuid, p_md_record->media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 134                 ret = minfo_mmeta_load(mb_svc_handle, mmeta, p_md_record);
 135         } else if (media_uuid != NULL) {
 136                 strncpy(mmeta->media_uuid, media_uuid, MB_SVC_UUID_LEN_MAX + 1);
 137
 138                 ret = minfo_mmeta_load(mb_svc_handle, mmeta, NULL);
 139                 if (ret < 0) {
 140                         free(mmeta);
 141                         return NULL;
 142                 }
 143         } else {
 144                 free(mmeta);
 145                 return NULL;
 146         }
 147
 148         return mmeta;
 149 }
 150
 151 void minfo_mmeta_destroy(Mmeta *mmeta)
 152 {
 153         if (mmeta != NULL && IS_MINFO_MMETA(mmeta)) {
 154                 if (mmeta->type == MINFO_ITEM_IMAGE && mmeta->image_info) {
 155                         minfo_mimage_destroy(mmeta->image_info);
 156                 }
 157                 if (mmeta->type == MINFO_ITEM_VIDEO && mmeta->video_info) {
 158                         minfo_mvideo_destroy(mmeta->video_info);
 159                 }
 160                 if (mmeta->media_uuid) {
 161                         free(mmeta->media_uuid);
 162                 }
 163                 if (mmeta->description) {
 164                         free(mmeta->description);
 165                 }
 166                 free(mmeta);
 167                 mmeta = NULL;
 168         }
 169 }
 170
 171 /*--------------------------mvideo-----------------------------*/
 172 static void _minfo_mvideo_init(Mvideo *mvideo);
 173
 174 static int _minfo_bm_ite_fn(Mbookmark *bookmark, void *user_data)
 175 {
 176         GList **list = (GList **) user_data;
 177         *list = g_list_append(*list, bookmark);
 178
 179         return 0;
 180 }
 181
 182 int minfo_mvideo_load(MediaSvcHandle *mb_svc_handle, const char *media_id, Mvideo *mvideo)
 183 {
 184         int ret = 0;
 185         int length = 0;
 186         mb_svc_video_meta_record_s video_meta_record = { 0 };
 187
 188         ret = mb_svc_get_video_record_by_media_id(mb_svc_handle, media_id, &video_meta_record);
 189         if (ret < 0) {
 190                 return ret;
 191         }
 192
 193         length = strlen(video_meta_record.album) + 1;
 194         mvideo->album_name = (char *)malloc(length);
 195         if (mvideo->album_name == NULL) {
 196                 return MB_SVC_ERROR_OUT_OF_MEMORY;
 197         }
 198         memset(mvideo->album_name, 0x00, length);
 199         strncpy(mvideo->album_name, video_meta_record.album, length);
 200
 201         length = strlen(video_meta_record.artist) + 1;
 202         mvideo->artist_name = (char *)malloc(length);
 203         if (mvideo->artist_name == NULL) {
 204                 return MB_SVC_ERROR_OUT_OF_MEMORY;
 205         }
 206         memset(mvideo->artist_name, 0x00, length);
 207         strncpy(mvideo->artist_name, video_meta_record.artist, length);
 208
 209         length = strlen(video_meta_record.title) + 1;
 210         mvideo->title = (char *)malloc(length);
 211         if (mvideo->title == NULL) {
 212                 return MB_SVC_ERROR_OUT_OF_MEMORY;
 213         }
 214         memset(mvideo->title, 0x00, length);
 215         strncpy(mvideo->title, video_meta_record.title, length);
 216
 217         length = strlen(video_meta_record.genre) + 1;
 218         mvideo->genre = (char *)malloc(length);
 219         if (mvideo->genre == NULL) {
 220                 return MB_SVC_ERROR_OUT_OF_MEMORY;
 221         }
 222         memset(mvideo->genre, 0x00, length);
 223         strncpy(mvideo->genre, video_meta_record.genre, length);
 224
 225         mvideo->last_played_pos = video_meta_record.last_played_time;
 226         mvideo->duration = video_meta_record.duration;
 227
 228         length = strlen(video_meta_record.youtube_category) + 1;
 229         mvideo->web_category = (char *)malloc(length);
 230         if (mvideo->web_category == NULL) {
 231                 return MB_SVC_ERROR_OUT_OF_MEMORY;
 232         }
 233         memset(mvideo->web_category, 0x00, length);
 234
 235         strncpy(mvideo->web_category, video_meta_record.youtube_category, length);
 236
 237         GList *tmp_list = NULL;
 238         minfo_get_bookmark_list(mb_svc_handle, media_id, _minfo_bm_ite_fn, &tmp_list);
 239         mvideo->bookmarks = tmp_list;
 240
 241         mvideo->_reserved = NULL;
 242
 243         return 0;
 244 }
 245
 246 static void _minfo_mvideo_init(Mvideo *mvideo)
 247 {
 248         mvideo->gtype = MINFO_TYPE_MVIDEO;
 249
 250         mvideo->album_name = NULL;
 251         mvideo->artist_name = NULL;
 252         mvideo->title = NULL;
 253         mvideo->genre = NULL;
 254         mvideo->last_played_pos = 0;
 255         mvideo->duration = 0;
 256         mvideo->web_category = NULL;
 257         mvideo->bookmarks = NULL;
 258         mvideo->_reserved = NULL;
 259 }
 260
 261 Mvideo *minfo_mvideo_new(MediaSvcHandle *mb_svc_handle, const char *id)
 262 {
 263         Mvideo *mvideo = NULL;
 264         int ret = 0;
 265
 266         mvideo = (Mvideo *) malloc(sizeof(Mvideo));
 267         if (mvideo == NULL) {
 268                 return NULL;
 269         }
 270
 271         if (id == NULL) {
 272                 _minfo_mvideo_init(mvideo);
 273         } else {
 274                 ret = minfo_mvideo_load(mb_svc_handle, id, mvideo);
 275                 if (ret < 0) {
 276                         minfo_mvideo_destroy(mvideo);
 277                         return NULL;
 278                 }
 279         }
 280
 281         return mvideo;
 282 }
 283
 284 void minfo_mvideo_destroy(Mvideo *mvideo)
 285 {
 286         int i = 0;
 287         Mbookmark *bookmark;
 288         if (mvideo != NULL && IS_MINFO_MVIDEO(mvideo)) {
 289                 if (mvideo->album_name) {
 290                         free(mvideo->album_name);
 291                 }
 292                 if (mvideo->artist_name) {
 293                         free(mvideo->artist_name);
 294                 }
 295                 if (mvideo->title) {
 296                         free(mvideo->title);
 297                 }
 298                 if (mvideo->genre) {
 299                         free(mvideo->genre);
 300                 }
 301                 if (mvideo->web_category) {
 302                         free(mvideo->web_category);
 303                 }
 304                 if (mvideo->bookmarks) {
 305                         for (i = 0;
 306                              i < g_list_length((GList *) mvideo->bookmarks);
 307                              i++) {
 308                                 bookmark =
 309                                     (Mbookmark *) g_list_nth_data((GList *)mvideo->bookmarks, i);
 310                                 if (bookmark)
 311                                         minfo_mbookmark_destroy(bookmark);
 312                         }
 313                         g_list_free(mvideo->bookmarks);
 314                 }
 315                 free(mvideo);
 316                 mvideo = NULL;
 317         }
 318 }
 319
 320 /*-------------------------mimage--------------------------*/
 321 static void _minfo_mimage_init(Mimage *mimage);
 322
 323 int minfo_mimage_load(MediaSvcHandle *mb_svc_handle, const char *media_id, Mimage *mimage)
 324 {
 325         mb_svc_image_meta_record_s image_meta_record = { 0 };
 326         int ret = 0;
 327
 328         ret = mb_svc_get_image_record_by_media_id(mb_svc_handle, media_id, &image_meta_record);
 329         if (ret < 0) {
 330                 return ret;
 331         }
 332
 333         mimage->orientation = image_meta_record.orientation;
 334         mimage->_reserved = NULL;
 335
 336         return 0;
 337 }
 338
 339 Mimage *minfo_mimage_new(MediaSvcHandle *mb_svc_handle, const char *id)
 340 {
 341         Mimage *mimage = NULL;
 342         int ret = 0;
 343
 344         mimage = (Mimage *) malloc(sizeof(Mimage));
 345         if (mimage == NULL) {
 346                 return NULL;
 347         }
 348
 349         if (id == NULL) {
 350                 _minfo_mimage_init(mimage);
 351         } else {
 352                 ret = minfo_mimage_load(mb_svc_handle, id, mimage);
 353                 if (ret < 0) {
 354                         free(mimage);
 355                         return NULL;
 356                 }
 357         }
 358
 359         return mimage;
 360 }
 361
 362 void minfo_mimage_destroy(Mimage *mimage)
 363 {
 364         if (mimage != NULL && IS_MINFO_MIMAGE(mimage)) {
 365                 free(mimage);
 366                 mimage = NULL;
 367         }
 368 }
 369
 370 static void _minfo_mimage_init(Mimage *mimage)
 371 {
 372         mimage->gtype = MINFO_TYPE_MIMAGE;
 373
 374         mimage->orientation = 0;
 375         mimage->_reserved = NULL;
 376 }