libtaginfo_c  0.2.0
taginfo_c.cc
1 /*
2  * Copyright (C) 2013 Jörn Magens
3  *
4  * This library is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * This Program is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12  * GNU General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public License
15  * along with this program; see the file LICENSE. If not, write to
16  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth
17  * Floor, Boston, MA 02110-1301 USA
18  * https://www.gnu.org/licenses/lgpl-2.1.txt
19  *
20  * Author:
21  * Jörn Magens <shuerhaaken@googlemail.com>
22  * Matias De lellis <mati86dl@gmail.com>
23  * Pavel Vasin <rat4vier@gmail.com>
24  */
25 
26 
27 #include "taginfo.h"
28 
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32 
33 #include "taginfo_c.h"
34 
35 
36 using namespace TagInfo;
37 using namespace TagLib;
38 
39 
40 //*****************STRING MANAGEMENT*****************************************************
41 static List<char *> strings;
42 static bool stringManagementEnabled = false;
43 
46  stringManagementEnabled = bool(management);
47 }
48 
52  if(!stringManagementEnabled)
53  return;
54 
55  for(List<char *>::Iterator it = strings.begin(); it != strings.end(); ++it)
56  free(*it);
57  strings.clear();
58 }
59 //*****************/STRING MANAGEMENT****************************************************
60 
61 static char **string_list_to_c_array(const StringList &list, int *out_length) {
62  if(list.isEmpty()) {
63  //cout << "list not there" << endl;
64  return NULL;
65  }
66  int len = list.size();
67  char **array = (char**)malloc(len * sizeof(char*));
68  int j = 0;
69  for(StringList::ConstIterator it = list.begin(); it != list.end(); ++it) {
70  array[j] = ::strdup((*it).toCString(false));
71  if(stringManagementEnabled && array[j])
72  strings.prepend(array[j]);
73  j++;
74  }
75  *out_length = len;
76  return array;
77 }
78 
79 static StringList string_list_from_c_array(const char* const* array, int length) {
80  StringList list;
81  for(int j = 0; j < length; j++) {
82  if(array[j]) {
83  list.append(array[j]);
84  }
85  }
86  return list;
87 }
88 
89 
90 //*****************FACTORY CREATION******************************************************
98 TagInfo_Info * taginfo_info_create(const char *filename) {
99  return reinterpret_cast<TagInfo_Info *>(Info::create(filename));
100 }
101 
109  TagInfo_MediaFileType media_file_type) {
110  return reinterpret_cast<TagInfo_Info *>(Info::create_with_file_type(filename,
111  (MediaFileType)media_file_type)
112  );
113 }
114 
121 TagInfo_Info * taginfo_info_create_from_mime(const char *filename, const char *mime_type) {
122  return reinterpret_cast<TagInfo_Info *>(Info::create_from_mime(filename,
123  mime_type)
124  );
125 }
126 //*****************/FACTORY CREATION*****************************************************
127 
128 BOOL taginfo_info_is_valid(TagInfo_Info *info) {
129  Info *i = reinterpret_cast<Info *>(info);
130  return i != NULL && i->is_valid();
131 }
132 
133 //*****************GENERAL MEMORY MANAGEMENT*********************************************
137 void taginfo_info_free(TagInfo_Info *info) {
139  delete reinterpret_cast<Info *>(info);
140 }
141 //*****************/GENERAL MEMORY MANAGEMENT********************************************
142 
143 
144 //*****************TAG READ/WRITE API****************************************************
148  Info *i = reinterpret_cast<Info *>(info);
149  return i->load();
150 }
154  Info *i = reinterpret_cast<Info *>(info);
155  return i->save();
156 }
157 
159 
162 char * taginfo_info_get_artist(const TagInfo_Info *info) {
164  const Info *i = reinterpret_cast<const Info *>(info);
165  String artist = i->get_artist();
166  char *s = ::strdup(artist.toCString(true));
167  if(stringManagementEnabled && s)
168  strings.prepend(s);
169  return s;
170 }
173 
176 void taginfo_info_set_artist(TagInfo_Info *info, const char *artist) {
177  Info *i = reinterpret_cast<Info *>(info);
178  i->set_artist(String(artist, String::UTF8));
179 }
180 
183 
187  const Info *i = reinterpret_cast<const Info *>(info);
188  String artist = i->get_original_artist ();
189  char *s = ::strdup(artist.toCString(true));
190  if(stringManagementEnabled && s)
191  strings.prepend(s);
192  return s;
193 }
196 
199 void taginfo_info_set_original_artist (TagInfo_Info *info, const char *artist) {
200  Info *i = reinterpret_cast<Info *>(info);
201  i->set_original_artist (String(artist, String::UTF8));
202 }
203 
206 
210  const Info *i = reinterpret_cast<const Info *>(info);
211  String album = i->get_album();
212  char *s = ::strdup(album.toCString(true));
213  if(stringManagementEnabled && s)
214  strings.prepend(s);
215  return s;
216 }
219 
222 void taginfo_info_set_album(TagInfo_Info *info, const char *album) {
223  Info *i = reinterpret_cast<Info *>(info);
224  i->set_album(String(album, String::UTF8));
225 }
226 
229 
233  const Info *i = reinterpret_cast<const Info *>(info);
234  String title = i->get_title();
235  char *s = ::strdup(title.toCString(true));
236  if(stringManagementEnabled && s)
237  strings.prepend(s);
238  return s;
239 }
242 
245 void taginfo_info_set_title(TagInfo_Info *info, const char *title) {
246  Info *i = reinterpret_cast<Info *>(info);
247  i->set_title(String(title, String::UTF8));
248 }
249 
252 
256  const Info *i = reinterpret_cast<const Info *>(info);
257  String album_artist = i->get_album_artist();
258  char *s = ::strdup(album_artist.toCString(true));
259  if(stringManagementEnabled && s)
260  strings.prepend(s);
261  return s;
262 }
265 
268 void taginfo_info_set_albumartist(TagInfo_Info *info, const char *albumartist) {
269  Info *i = reinterpret_cast<Info *>(info);
270  i->set_album_artist(String(albumartist, String::UTF8));
271 }
272 
275 
279  const Info *i = reinterpret_cast<const Info *>(info);
280  String comments = i->get_comments();
281  char *s = ::strdup(comments.toCString(true));
282  if(stringManagementEnabled && s)
283  strings.prepend(s);
284  return s;
285 }
288 
291 void taginfo_info_set_comment(TagInfo_Info *info, const char *comment) {
292  Info *i = reinterpret_cast<Info *>(info);
293  i->set_comments(String(comment, String::UTF8));
294 }
295 
298 
302  const Info *i = reinterpret_cast<const Info *>(info);
303  String composer = i->get_composer();
304  char *s = ::strdup(composer.toCString(true));
305  if(stringManagementEnabled && s)
306  strings.prepend(s);
307  return s;
308 }
311 
314 void taginfo_info_set_composer(TagInfo_Info *info, const char *composer) {
315  Info *i = reinterpret_cast<Info *>(info);
316  i->set_composer(String(composer, String::UTF8));
317 }
318 
321 
325  const Info *i = reinterpret_cast<const Info *>(info);
326  String homepage = i->get_homepage();
327  char *s = ::strdup(homepage.toCString(true));
328  if(stringManagementEnabled && s)
329  strings.prepend(s);
330  return s;
331 }
334 
337 void taginfo_info_set_homepage(TagInfo_Info *info, const char *homepage) {
338  Info *i = reinterpret_cast<Info *>(info);
339  i->set_homepage(String(homepage, String::UTF8));
340 }
341 
344 
348  const Info *i = reinterpret_cast<const Info *>(info);
349  String encoder = i->get_encoder();
350  char *s = ::strdup(encoder.toCString(true));
351  if(stringManagementEnabled && s)
352  strings.prepend(s);
353  return s;
354 }
357 
360 void taginfo_info_set_encoder(TagInfo_Info *info, const char *encoder) {
361  Info *i = reinterpret_cast<Info *>(info);
362  i->set_encoder(String(encoder, String::UTF8));
363 }
364 
367 
371  const Info *i = reinterpret_cast<const Info *>(info);
372  String copyright = i->get_copyright();
373  char *s = ::strdup(copyright.toCString(true));
374  if(stringManagementEnabled && s)
375  strings.prepend(s);
376  return s;
377 }
380 
383 void taginfo_info_set_copyright(TagInfo_Info *info, const char *copyright) {
384  Info *i = reinterpret_cast<Info *>(info);
385  i->set_copyright(String(copyright, String::UTF8));
386 }
387 
390 
394  const Info *i = reinterpret_cast<const Info *>(info);
395  String genre = i->get_genre();
396  char *s = ::strdup(genre.toCString(true));
397  if(stringManagementEnabled && s)
398  strings.prepend(s);
399  return s;
400 }
403 
406 void taginfo_info_set_genre(TagInfo_Info *info, const char *genre) {
407  Info *i = reinterpret_cast<Info *>(info);
408  i->set_genre(String(genre, String::UTF8));
409 }
410 
413 
417  const Info *i = reinterpret_cast<const Info *>(info);
418  return i->get_track_number();
419 }
422 
425 void taginfo_info_set_track_number(TagInfo_Info *info, int track_number) {
426  Info *i = reinterpret_cast<Info *>(info);
427  i->set_track_number(track_number);
428 }
429 
432 
436  const Info *i = reinterpret_cast<const Info *>(info);
437  return i->get_track_count();
438 }
441 
444 void taginfo_info_set_track_count(TagInfo_Info *info, int track_count) {
445  Info *i = reinterpret_cast<Info *>(info);
446  i->set_track_count(track_count);
447 }
448 
451 
455  const Info *i = reinterpret_cast<const Info *>(info);
456  return i->get_year();
457 }
460 
463 void taginfo_info_set_year(TagInfo_Info *info, int year) {
464  Info *i = reinterpret_cast<Info *>(info);
465  i->set_year(year);
466 }
467 
474  const Info *i = reinterpret_cast<const Info *>(info);
475  return i->get_bitrate();
476 }
477 
484  const Info *i = reinterpret_cast<const Info *>(info);
485  return i->get_samplerate();
486 }
487 
494  const Info *i = reinterpret_cast<const Info *>(info);
495  return i->get_channels();
496 }
497 
504  const Info *i = reinterpret_cast<const Info *>(info);
505  return i->get_length_seconds();
506 }
507 
509 
514  const Info *i = reinterpret_cast<const Info *>(info);
515  //bool image_available = i->get_has_image();
516  return i->get_has_image();
517 }
518 
520 
525  const Info *i = reinterpret_cast<const Info *>(info);
526  return i->get_volume_number();
527 }
529 
534  Info *i = reinterpret_cast<Info *>(info);
535  i->set_volume_number(number);
536 }
537 
538 
540 
545  const Info * i = reinterpret_cast<const Info *>(info);
546  return i->get_beats_per_minute();
547 }
549 
554  Info * i = reinterpret_cast<Info *>(info);
555  i->set_beats_per_minute(new_bpm);
556 }
557 
559 
564  const Info *i = reinterpret_cast<const Info *>(info);
565  return i->get_volume_count();
566 }
568 
573  Info *i = reinterpret_cast<Info *>(info);
574  i->set_volume_count(count);
575 }
576 
578 
583  const Info *i = reinterpret_cast<const Info *>(info);
584  return i->get_rating();
585 }
587 
591 void taginfo_info_set_rating(TagInfo_Info *info, int rating) {
592  Info *i = reinterpret_cast<Info *>(info);
593  i->set_rating(rating);
594 }
595 
597 
602  const Info *i = reinterpret_cast<const Info *>(info);
603  return i->get_playcount();
604 }
606 
610 void taginfo_info_set_playcount(TagInfo_Info *info, int count) {
611  Info *i = reinterpret_cast<Info *>(info);
612  i->set_playcount(count);
613 }
614 
616 
621  const Info *i = reinterpret_cast<const Info *>(info);
622  BOOL s = i->get_is_compilation();
623  return s;
624 }
626 
630 void taginfo_info_set_is_compilation(TagInfo_Info *info, BOOL is_compilation) {
631  Info *i = reinterpret_cast<Info *>(info);
632  i->set_is_compilation((bool)is_compilation);
633 }
634 
636 
642  int *labels_length) {
643  const Info *i = reinterpret_cast<const Info *>(info);
644  StringList list = i->get_track_labels_list();
645  return string_list_to_c_array(list, labels_length);
646 }
648 
654  const char* const* labels, int labels_length) {
655  Info *i = reinterpret_cast<Info *>(info);
656  StringList list = string_list_from_c_array(labels, labels_length);
657  i->set_track_labels_list(list);
658 }
659 
661 
667  int *labels_length) {
668  const Info *i = reinterpret_cast<const Info *>(info);
669  StringList list = i->get_album_labels_list();
670  return string_list_to_c_array(list, labels_length);
671 }
673 
679  const char* const* labels, int labels_length) {
680  Info *i = reinterpret_cast<Info *>(info);
681  StringList list = string_list_from_c_array(labels, labels_length);
682  i->set_album_labels_list(list);
683 }
684 
686 
692  int * labels_length) {
693  const Info *i = reinterpret_cast<const Info *>(info);
694  StringList list = i->get_artist_labels_list();
695  return string_list_to_c_array(list, labels_length);
696 }
698 
704  const char* const* labels, int labels_length) {
705  Info *i = reinterpret_cast<Info *>(info);
706  StringList list = string_list_from_c_array(labels, labels_length);
707  i->set_artist_labels_list(list);
708 }
709 
710 //****************/TAG READ/WRITE API****************************************************
711 
712 
713 
714 
715 Image ** image_list_to_image_array(const ImageList &images, int &image_count) {
716  image_count = 0;
717  if(0 < images.size()) {
718  Image ** image_array = new Image*[images.size()];
719  int i = 0;
720  for(ImageList::ConstIterator it = images.begin(); it != images.end(); ++it) {
721  image_array[i] = *it;
722  image_count++;
723  }
724  return image_array;
725  }
726  return NULL;
727 }
728 
729 //*****************IMAGES****************************************************************
731 
737  int *image_count) {
738  const Info *i = reinterpret_cast<const Info *>(info);
739  ImageList image_list = i->get_images();
740  image_list.setAutoDelete(false);
741  TagInfo_Image ** images = reinterpret_cast<TagInfo_Image **> (image_list_to_image_array(image_list, *image_count));
742  return images;
743 }
744 
745 
746 ImageList image_array_to_image_list(Image ** image_array, int image_count) {
747  ImageList list;
748  list.setAutoDelete(false);
749  for(int i = 0; i < image_count; i++) {
750  list.append(reinterpret_cast<Image *>(image_array[i]));
751  }
752  return list;
753 }
754 
756 
762  TagInfo_Image ** images, const int image_count) {
763  Info *i = reinterpret_cast<Info *>(info);
764  const ImageList img_list = image_array_to_image_list(reinterpret_cast<Image **>(images), image_count);
765  i->set_images(img_list);
766 }
767 
771  Image * i = new Image();
772  return reinterpret_cast<TagInfo_Image *>(i);
773 }
774 
776 
781 char * taginfo_image_get_data(const TagInfo_Image * img, unsigned int * bin_data_length) {
782  if(!img)
783  return NULL;
784  const Image *i = reinterpret_cast<const Image *>(img);
785  return i->get_data(*bin_data_length);
786 }
787 
789 
794 void taginfo_image_set_data(TagInfo_Image * img, char * bin_data, unsigned int bin_data_length) {
795  if(!img || bin_data_length <= 0)
796  return;
797  Image *i = reinterpret_cast<Image *>(img);
798  i->set_data(bin_data, bin_data_length);
799 }
800 
802 
807  if(!img)
809  const Image *i = reinterpret_cast<const Image *>(img);
810  return static_cast<TagInfo_ImageContentType>(i->get_content_type());
811 }
812 
814 
819  if(!img)
820  return;
821  Image *i = reinterpret_cast<Image *>(img);
822  i->set_content_type(static_cast<Image::ContentType>(itype));
823 }
824 
826 
831  if(!img)
833  const Image *i = reinterpret_cast<const Image *>(img);
834  return static_cast<TagInfo_ImageFileType>(i->get_file_type());
835 }
836 
838 
843  if(!img)
844  return;
845  Image *i = reinterpret_cast<Image *>(img);
846  i->set_file_type(static_cast<Image::FileType>(image_f_type));
847 }
848 
850 
855  if(!img)
856  return NULL;
857  const Image *i = reinterpret_cast<const Image *>(img);
858  return ::strdup(i->get_description().toCString(false));
859 }
860 
862 
866 void taginfo_image_set_description(TagInfo_Image * img, const char * new_description) {
867  if(!img)
868  return;
869  Image *i = reinterpret_cast<Image *>(img);
870  String s = String();
871  if(!new_description)
872  i->set_description(s);
873  else
874  i->set_description(new_description);
875 }
876 
877 
881 void taginfo_image_free(TagInfo_Image * img) {
883  if(!img)
884  return;
885  Image *i = reinterpret_cast<Image *>(img);
886  delete i;
887  i = NULL;
888 }
889 
893 void taginfo_image_array_free(TagInfo_Image ** img_arr) {
895  if(!img_arr)
896  return;
897  for(TagInfo_Image ** it = img_arr; *it != NULL; it++) {
898  taginfo_image_free(*it);
899  }
900  img_arr = NULL;
901 }
902 //*****************/IMAGES***************************************************************
903 
904 
905 //*****************LYRICS****************************************************************
907 
910 char * taginfo_info_get_lyrics(const TagInfo_Info *info) {
912  const Info *i = reinterpret_cast<const Info *>(info);
913  String lyrics = i->get_lyrics();
914  char *s = ::strdup(lyrics.toCString(true));
915  if(stringManagementEnabled && s)
916  strings.prepend(s);
917  return s;
918 }
919 
921 
924 void taginfo_info_set_lyrics(TagInfo_Info *info, const char * lyrics) {
926  Info *i = reinterpret_cast<Info *>(info);
927  i->set_lyrics(String(lyrics));
928 }
929 //*****************/LYRICS***************************************************************
930 
char * taginfo_info_get_composer(const TagInfo_Info *info)
Definition: taginfo_c.cc:301
int taginfo_info_get_track_count(const TagInfo_Info *info)
Definition: taginfo_c.cc:435
TagInfo_Info * taginfo_info_create_from_mime(const char *filename, const char *mime_type)
Definition: taginfo_c.cc:121
BOOL taginfo_info_save(TagInfo_Info *info)
Definition: taginfo_c.cc:153
void taginfo_info_set_track_labels(TagInfo_Info *info, const char *const *data, int data_length)
Set an array of user defined track labels.
Definition: taginfo_c.cc:653
void taginfo_info_set_artist(TagInfo_Info *info, const char *artist)
Definition: taginfo_c.cc:176
TagInfo_Image ** taginfo_info_get_images(const TagInfo_Info *info, int *image_count)
Get an array of images copied from the file embedded images.
Definition: taginfo_c.cc:736
void taginfo_image_set_content_type(TagInfo_Image *img, TagInfo_ImageContentType itype)
Set the content's type of the image.
Definition: taginfo_c.cc:818
TagInfo_Info * taginfo_info_create(const char *filename)
Definition: taginfo_c.cc:98
BOOL taginfo_info_get_has_image(const TagInfo_Info *info)
Get information on the availability of an image that is embedded in the media file.
Definition: taginfo_c.cc:513
Unknown image file type.
Definition: taginfo_c.h:182
int taginfo_info_get_playcount(const TagInfo_Info *info)
Get the play count of a media track.
Definition: taginfo_c.cc:601
char * taginfo_info_get_artist(const TagInfo_Info *info)
Get the artist tag of a media track.
Definition: taginfo_c.cc:163
int taginfo_info_get_channels(const TagInfo_Info *info)
Definition: taginfo_c.cc:493
void taginfo_info_set_title(TagInfo_Info *info, const char *title)
Definition: taginfo_c.cc:245
TagInfo_ImageFileType
is an enumeration of image file types for embedded images
Definition: taginfo_c.h:180
#define BOOL
Boolean value as integer.
Definition: taginfo_c.h:120
void taginfo_info_set_rating(TagInfo_Info *info, int rating)
Set the rating tag of a media track. rating 1 - 5; 0 -> not set.
Definition: taginfo_c.cc:591
void taginfo_info_set_track_number(TagInfo_Info *info, int track_number)
Definition: taginfo_c.cc:425
int taginfo_info_get_rating(const TagInfo_Info *info)
Get the rating of a media track. rating 1 - 5; 0 -> not set.
Definition: taginfo_c.cc:582
char * taginfo_info_get_homepage(const TagInfo_Info *info)
Definition: taginfo_c.cc:324
BOOL taginfo_info_load(TagInfo_Info *info)
Definition: taginfo_c.cc:147
char * taginfo_info_get_albumartist(const TagInfo_Info *info)
Definition: taginfo_c.cc:255
void taginfo_image_set_file_type(TagInfo_Image *img, TagInfo_ImageFileType image_f_type)
Set the file's type of the image.
Definition: taginfo_c.cc:842
void taginfo_info_set_encoder(TagInfo_Info *info, const char *encoder)
Definition: taginfo_c.cc:360
char * taginfo_info_get_album(const TagInfo_Info *info)
Definition: taginfo_c.cc:209
void taginfo_info_set_original_artist(TagInfo_Info *info, const char *artist)
Definition: taginfo_c.cc:199
void taginfo_info_set_is_compilation(TagInfo_Info *info, BOOL is_compilation)
Set the information if the media file is part of a compilation / VA album.
Definition: taginfo_c.cc:630
char * taginfo_info_get_encoder(const TagInfo_Info *info)
Definition: taginfo_c.cc:347
int taginfo_info_get_length(const TagInfo_Info *info)
Definition: taginfo_c.cc:503
void taginfo_image_free(TagInfo_Image *img)
Definition: taginfo_c.cc:882
void taginfo_info_set_comment(TagInfo_Info *info, const char *comment)
Definition: taginfo_c.cc:291
TagInfo_ImageFileType taginfo_image_get_file_type(const TagInfo_Image *img)
Get the file's type of the image.
Definition: taginfo_c.cc:830
void taginfo_info_set_albumartist(TagInfo_Info *info, const char *albumartist)
Definition: taginfo_c.cc:268
TagInfo_MediaFileType
is an enumeration of media file types supported in libtaginfo
Definition: taginfo_c.h:125
int taginfo_info_get_beats_per_minute(const TagInfo_Info *info)
Get the BPM of a media track.
Definition: taginfo_c.cc:544
void taginfo_info_set_track_count(TagInfo_Info *info, int track_number)
Definition: taginfo_c.cc:444
void taginfo_info_set_artist_labels(TagInfo_Info *info, const char *const *data, int data_length)
Set an array of user defined artist labels.
Definition: taginfo_c.cc:703
void taginfo_info_set_volume_number(TagInfo_Info *info, int number)
Set the volume number tag of a media track.
Definition: taginfo_c.cc:533
void taginfo_info_set_copyright(TagInfo_Info *info, const char *copyright)
Definition: taginfo_c.cc:383
TagInfo_ImageContentType taginfo_image_get_content_type(const TagInfo_Image *img)
Get the content's type of the image.
Definition: taginfo_c.cc:806
int taginfo_info_get_volume_number(const TagInfo_Info *info)
Get the volume number of a media track.
Definition: taginfo_c.cc:524
TagInfo_ImageContentType
enumeration for image content description
Definition: taginfo_c.h:195
TagInfo_Image * taginfo_image_new()
Definition: taginfo_c.cc:770
void taginfo_image_array_free(TagInfo_Image **img_arr)
Definition: taginfo_c.cc:894
char * taginfo_info_get_lyrics(const TagInfo_Info *info)
Get a lyrics string from the media file.
Definition: taginfo_c.cc:911
void taginfo_info_free_strings()
Definition: taginfo_c.cc:51
char ** taginfo_info_get_album_labels(const TagInfo_Info *info, int *data_length)
Get an array of user defined album labels.
Definition: taginfo_c.cc:666
void taginfo_info_set_album_labels(TagInfo_Info *info, const char *const *data, int data_length)
Set an array of user defined album labels.
Definition: taginfo_c.cc:678
void taginfo_info_set_composer(TagInfo_Info *info, const char *composer)
Definition: taginfo_c.cc:314
An image type not listed here.
Definition: taginfo_c.h:197
void taginfo_info_set_year(TagInfo_Info *info, int year)
Definition: taginfo_c.cc:463
int taginfo_info_get_volume_count(const TagInfo_Info *info)
Get the volume count of a media track.
Definition: taginfo_c.cc:563
int taginfo_info_get_bitrate(const TagInfo_Info *info)
Definition: taginfo_c.cc:473
char ** taginfo_info_get_artist_labels(const TagInfo_Info *info, int *data_length)
Get an array of user defined artist labels.
Definition: taginfo_c.cc:691
void taginfo_info_set_playcount(TagInfo_Info *info, int count)
Set the play count tag of a media track.
Definition: taginfo_c.cc:610
void taginfo_info_set_lyrics(TagInfo_Info *info, const char *lyrics)
Set a lyrics string to the media file.
Definition: taginfo_c.cc:925
char * taginfo_info_get_title(const TagInfo_Info *info)
Definition: taginfo_c.cc:232
char * taginfo_info_get_original_artist(const TagInfo_Info *info)
Definition: taginfo_c.cc:186
void taginfo_info_set_volume_count(TagInfo_Info *info, int count)
Set the volume count tag of a media track.
Definition: taginfo_c.cc:572
char * taginfo_info_get_copyright(const TagInfo_Info *info)
Definition: taginfo_c.cc:370
void taginfo_info_set_homepage(TagInfo_Info *info, const char *homepage)
Definition: taginfo_c.cc:337
void taginfo_info_set_beats_per_minute(TagInfo_Info *info, int new_bpm)
Set the BPM of a media track.
Definition: taginfo_c.cc:553
char * taginfo_info_get_genre(const TagInfo_Info *info)
Definition: taginfo_c.cc:393
void taginfo_info_set_genre(TagInfo_Info *info, const char *genre)
Definition: taginfo_c.cc:406
void taginfo_image_set_description(TagInfo_Image *img, const char *new_description)
Set the file's type of the image.
Definition: taginfo_c.cc:866
char ** taginfo_info_get_track_labels(const TagInfo_Info *info, int *data_length)
Get an array of user defined track labels.
Definition: taginfo_c.cc:641
char * taginfo_image_get_description(const TagInfo_Image *img)
Get the file's type of the image.
Definition: taginfo_c.cc:854
char * taginfo_info_get_comment(const TagInfo_Info *info)
Definition: taginfo_c.cc:278
void taginfo_info_set_album(TagInfo_Info *info, const char *album)
Definition: taginfo_c.cc:222
int taginfo_info_get_samplerate(const TagInfo_Info *info)
Definition: taginfo_c.cc:483
int taginfo_info_get_year(const TagInfo_Info *info)
Definition: taginfo_c.cc:454
BOOL taginfo_info_get_is_compilation(const TagInfo_Info *info)
Get the information if the media file is part of a compilation / VA album.
Definition: taginfo_c.cc:620
char * taginfo_image_get_data(const TagInfo_Image *img, unsigned int *bin_data_length)
Get the binary data of the image.
Definition: taginfo_c.cc:781
void taginfo_image_set_data(TagInfo_Image *img, char *bin_data, unsigned int bin_data_length)
Set the binary data of the image.
Definition: taginfo_c.cc:794
void taginfo_info_free(TagInfo_Info *info)
Definition: taginfo_c.cc:138
void taginfo_info_enable_string_management(BOOL management)
Enable string management for libtaginfo.
Definition: taginfo_c.cc:45
int taginfo_info_get_track_number(const TagInfo_Info *info)
Definition: taginfo_c.cc:416
void taginfo_info_set_images(TagInfo_Info *info, TagInfo_Image **images, const int image_count)
Set an array of TagInfo_Image to be embedded into the media file.
Definition: taginfo_c.cc:761
TagInfo_Info * taginfo_info_create_with_file_type(const char *filename, TagInfo_MediaFileType format)
Definition: taginfo_c.cc:108