~ubuntu-branches/ubuntu/raring/tracker/raring

« back to all changes in this revision

Viewing changes to src/tracker-extract/tracker-extract-mp3.c

• browse files at revision 64
• compare with another revision
• download diff
• download tarball
• view history from revision 64

Show diffs side-by-side

added

removed

src/tracker-extract/tracker-extract-mp3.c

482

482

        g_free (tags->title3);

483

483

}

484

484

 

 

485

static gboolean

 

486

guess_dlna_profile (gint          bitrate,

 

487

                    gint          frequency,

 

488

                    gint          mpeg_version,

 

489

                    gint          layer_version,

 

490

                    gint          n_channels,

 

491

                    const gchar **dlna_profile,

 

492

                    const gchar **dlna_mimetype)

 

493

{

 

494

        if (mpeg_version == MPEG_V1 &&

 

495

            layer_version == LAYER_3 &&

 

496

            (bitrate >= 32000 && bitrate <= 320000) &&

 

497

            (n_channels == 1 || n_channels == 2) &&

 

498

            (frequency == freq_table[0][0] ||

 

499

             frequency == freq_table[1][0] ||

 

500

             frequency == freq_table[2][0])) {

 

501

                *dlna_profile = "MP3";

 

502

                *dlna_mimetype = "audio/mpeg";

 

503

                return TRUE;

 

504

        }

 

505

 

 

506

        if ((bitrate >= 8000 && bitrate <= 320000) &&

 

507

            (mpeg_version == MPEG_V1 || mpeg_version == MPEG_V2) &&

 

508

            (frequency == freq_table[0][0] || frequency == freq_table[0][1] ||

 

509

             frequency == freq_table[1][0] || frequency == freq_table[1][1] ||

 

510

             frequency == freq_table[2][0] || frequency == freq_table[2][1])) {

 

511

                *dlna_profile = "MP3X";

 

512

                *dlna_mimetype = "audio/mpeg";

 

513

                return TRUE;

 

514

        }

 

515

 

 

516

        return FALSE;

 

517

}

 

518

 

485

519

static char *

486

520

read_id3v1_buffer (int     fd,

487

521

                   goffset size)

817

851

                  TrackerSparqlBuilder *metadata,

818

852

                  MP3Data              *filedata)

819

853

{

 

854

        const gchar *dlna_profile, *dlna_mimetype;

820

855

        guint header;

821

856

        gchar mpeg_ver = 0;

822

857

        gchar layer_ver = 0;

831

866

        guint frame_size;

832

867

        guint frames = 0;

833

868

        size_t pos = 0;

 

869

        gint n_channels;

834

870

 

835

871

        pos = seek_pos;

836

872

 

932

968

        tracker_sparql_builder_predicate (metadata, "nfo:codec");

933

969

        tracker_sparql_builder_object_string (metadata, "MPEG");

934

970

 

 

971

        n_channels = ((header & ch_mask) == ch_mask) ? 1 : 2;

 

972

 

935

973

        tracker_sparql_builder_predicate (metadata, "nfo:channels");

936

 

        if ((header & ch_mask) == ch_mask) {

937

 

                tracker_sparql_builder_object_int64 (metadata, 1);

938

 

        } else {

939

 

                tracker_sparql_builder_object_int64 (metadata, 2);

940

 

        }

 

974

        tracker_sparql_builder_object_int64 (metadata, n_channels);

941

975

 

942

976

        avg_bps /= frames;

943

977

 

958

992

        tracker_sparql_builder_predicate (metadata, "nfo:averageBitrate");

959

993

        tracker_sparql_builder_object_int64 (metadata, avg_bps*1000);

960

994

 

 

995

        if (guess_dlna_profile (bitrate, sample_rate,

 

996

                                mpeg_ver, layer_ver, n_channels,

 

997

                                &dlna_profile, &dlna_mimetype)) {

 

998

                tracker_sparql_builder_predicate (metadata, "nmm:dlnaProfile");

 

999

                tracker_sparql_builder_object_string (metadata, dlna_profile);

 

1000

        }

 

1001

 

961

1002

        return TRUE;

962

1003

}

963

1004

 

1016

1057

        switch (encoding) {

1017

1058

        case 0x01:

1018

1059

        case 0x02:

 

1060

                

1019

1061

                /* UTF-16, string terminated by two NUL bytes */

1020

 

                pos = memmem (text, len, "\0\0", 2);

 

1062

                pos = memmem (text, len, "\0\0\0", 3);

 

1063

 

 

1064

                if (pos == NULL) {

 

1065

                        pos = memmem (text, len, "\0\0", 2);

 

1066

                } else {

 

1067

                        pos++;

 

1068

                }

 

1069

 

1021

1070

                if (pos != NULL) {

1022

1071

                        return pos - text;

1023

1072

                } else {

1031

1080

static gchar *

1032

1081

id3v24_text_to_utf8 (const gchar  encoding,

1033

1082

                     const gchar *text,

1034

 

                     gssize       len)

 

1083

                     gssize       len,

 

1084

                     id3tag      *info)

1035

1085

{

1036

1086

        /* This byte describes the encoding

1037

1087

         * try to convert strings to UTF-8

1047

1097

                return convert_to_encoding (text,

1048

1098

                                            len,

1049

1099

                                            "UTF-8",

1050

 

                                            "Windows-1252",

 

1100

                                            info->encoding ? info->encoding : "Windows-1252",

1051

1101

                                            NULL, NULL, NULL);

1052

1102

        case 0x01 :

1053

1103

                return convert_to_encoding (text,

1072

1122

                return convert_to_encoding (text,

1073

1123

                                            len,

1074

1124

                                            "UTF-8",

1075

 

                                            "Windows-1252",

 

1125

                                            info->encoding ? info->encoding : "Windows-1252",

1076

1126

                                            NULL, NULL, NULL);

1077

1127

        }

1078

1128

}

1080

1130

static gchar *

1081

1131

id3v2_text_to_utf8 (const gchar  encoding,

1082

1132

                    const gchar *text,

1083

 

                    gssize       len)

 

1133

                    gssize       len,

 

1134

                    id3tag      *info)

1084

1135

{

1085

1136

        /* This byte describes the encoding

1086

1137

         * try to convert strings to UTF-8

1096

1147

                return convert_to_encoding (text,

1097

1148

                                            len,

1098

1149

                                            "UTF-8",

1099

 

                                            "Windows-1252",

 

1150

                                            info->encoding ? info->encoding : "Windows-1252",

1100

1151

                                            NULL, NULL, NULL);

1101

1152

        case 0x01 :

1102

1153

                /* return g_convert (text, */

1114

1165

                return convert_to_encoding (text,

1115

1166

                                            len,

1116

1167

                                            "UTF-8",

1117

 

                                            "Windows-1252",

 

1168

                                            info->encoding ? info->encoding : "Windows-1252",

1118

1169

                                            NULL, NULL, NULL);

1119

1170

        }

1120

1171

}

1232

1283

                offset        = 4 + text_desc_len + id3v2_nul_size (text_encode);

1233

1284

                text          = &data[pos + offset]; /* <full text string according to encoding> */

1234

1285

 

1235

 

                word = id3v24_text_to_utf8 (text_encode, text, csize - offset);

 

1286

                word = id3v24_text_to_utf8 (text_encode, text, csize - offset, info);

1236

1287

 

1237

1288

                if (!tracker_is_empty_string (word)) {

1238

1289

                        g_strstrip (word);

1248

1299

                gchar *word;

1249

1300

 

1250

1301

                /* text frames */

1251

 

                word = id3v24_text_to_utf8 (data[pos], &data[pos + 1], csize - 1);

 

1302

                word = id3v24_text_to_utf8 (data[pos], &data[pos + 1], csize - 1, info);

1252

1303

                if (!tracker_is_empty_string (word)) {

1253

1304

                        g_strstrip (word);

1254

1305

                }

1418

1469

                offset        = 4 + text_desc_len + id3v2_nul_size (text_encode);

1419

1470

                text          = &data[pos + offset]; /* <full text string according to encoding> */

1420

1471

 

1421

 

                word = id3v2_text_to_utf8 (text_encode, text, csize - offset);

 

1472

                word = id3v2_text_to_utf8 (text_encode, text, csize - offset, info);

1422

1473

 

1423

1474

                if (!tracker_is_empty_string (word)) {

1424

1475

                        g_strstrip (word);

1435

1486

                gchar *word;

1436

1487

 

1437

1488

                /* text frames */

1438

 

                word = id3v2_text_to_utf8 (data[pos], &data[pos + 1], csize - 1);

 

1489

                word = id3v2_text_to_utf8 (data[pos], &data[pos + 1], csize - 1, info);

1439

1490

 

1440

1491

                if (!tracker_is_empty_string (word)) {

1441

1492

                        g_strstrip (word);

1581

1632

                /* text frames */

1582

1633

                gchar *word;

1583

1634

 

1584

 

                word = id3v2_text_to_utf8 (data[pos], &data[pos + 1], csize - 1);

 

1635

                word = id3v2_text_to_utf8 (data[pos], &data[pos + 1], csize - 1, info);

1585

1636

                if (!tracker_is_empty_string (word)) {

1586

1637

                        g_strstrip (word);

1587

1638

                }

2095

2146

 

2096

2147

        g_free (id3v1_buffer);

2097

2148

 

 

2149

        if (md.id3v1.encoding != NULL) {

 

2150

                gchar *locale;

 

2151

 

 

2152

                locale = tracker_locale_get (TRACKER_LOCALE_LANGUAGE);

 

2153

                if (!g_str_has_prefix (locale, "ru") &&

 

2154

                    !g_str_has_prefix (locale, "uk")) {

 

2155

                        /* use guessed encoding for ID3v2 tags only in selected locales

 

2156

                           where broken ID3v2 is widespread */

 

2157

                        g_free (md.id3v1.encoding);

 

2158

                        md.id3v1.encoding = NULL;

 

2159

                }

 

2160

                g_free (locale);

 

2161

                locale = NULL;

 

2162

        }

 

2163

 

2098

2164

        /* Get other embedded tags */

2099

2165

        audio_offset = parse_id3v2 (buffer, buffer_size, &md.id3v1, uri, metadata, &md);

2100

2166

 

2397

2463

 

2398

2464

        g_free (md.album_uri);

2399

2465

 

2400

 

        /* FIXME We use a hardcoded value here for now. In reality there's a second option MP3X */

2401

 

        tracker_sparql_builder_predicate (metadata, "nmm:dlnaProfile");

2402

 

        tracker_sparql_builder_object_string (metadata, "MP3");

2403

 

 

2404

2466

        /* Get mp3 stream info */

2405

2467

        mp3_parse (buffer, buffer_size, audio_offset, uri, metadata, &md);

2406

2468

 

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.1