Esempio n. 1
0
/* called after all jobs are finshed. Files are cleaned up and renamed */
void job_finisher(_main_data *main_data)
{
    int i;
    static char status_message[(MAX_FILE_PATH_LENGTH + MAX_FILE_NAME_LENGTH) * MAX_NUM_TRACK ];
    static char buffer[(MAX_FILE_PATH_LENGTH + MAX_FILE_NAME_LENGTH) * MAX_NUM_TRACK ];
    static char *wav_file, *enc_file;
    int madewavs = FALSE;
    int mademp3s = FALSE;
    int tracksdone = 0;
    char *s_track_num;
    char *artist;
    ID3Tag *myTag;

    FILE *fp_playlist = NULL;
    char playlist_filespec[ MAX_FILE_PATH_LENGTH + MAX_FILE_NAME_LENGTH ];

    /* Allocate space dynamically.  This is overkill, but certainly won't be a problem. */
    s_track_num = (char *) malloc((main_data->num_tracks + 2) * sizeof(char));
    buffer[0] = 0;

    /* Clean up */
    for(i = 0; i < main_data->num_tracks; i++)
    {
        create_file_names_for_track(main_data, i, &wav_file, &enc_file);

        if(main_data->track[ i ].wav_exist == FALSE)
        {
            unlink(wav_file);
        }
        else if(main_data->track[ i ].make_wav == TRUE)
        {
            madewavs = TRUE;
            sprintf(&buffer[strlen(buffer)], "%d: %s\n", ++tracksdone, file_name_without_path(wav_file));
        }

        main_data->track[ i ].make_wav = FALSE;

        if(main_data->track[ i ].mp3_exist == TRUE && main_data->track[ i ].make_mp3 == TRUE)
        {
            mademp3s = TRUE;

            /* add ID3 tag if requested */
            if(config.cddb_config.create_id3 == TRUE)
            {
                if(!(artist = main_data->track[ i ].artist))
                {
                    artist = main_data->disc_artist;
                }

                // TODO:  fix this to use something like
                //		if (main_data->encoding_type == OGG) {

                if(!strcmp(config.encoder.encoder, "oggenc"))
                {
                    /* set VORBIS tags using vorbistag - added DATE tag - R. Turnbull 1-2-2010 */
                    vorbistag(enc_file,
                              artist,
                              main_data->disc_title,
                              main_data->disc_year,
                              main_data->track[i].title,
                              id3_find_cddb_category(main_data->disc_category),
                              i + 1);
                }
                else if(!strcmp(config.encoder.encoder, "flac"))
                {
                    /* set FLAC tags using metaflac R. Turnbull 1-2-2010 */
                    flactag(enc_file,
                            artist,
                            main_data->disc_title,
                            main_data->disc_year,
                            main_data->track[i].title,
                            id3_find_cddb_category(main_data->disc_category),
                            i + 1);
                }
                else if(!strcmp(config.encoder.encoder, "mppenc"))
                {
                    /* do nothing for for musepack right now -
                        originally supported id3 now wants apev2 tags */
                }
                else
                {
                    /* assume MP3 tag is desired */
                    sprintf(s_track_num,"%d",(i+1));

                    myTag=ID3Tag_New();
                    ID3Tag_Link(myTag,enc_file);

                    set_TagField(myTag, main_data->track[ i ].title, ID3FID_TITLE);
                    set_TagField(myTag, artist, ID3FID_LEADARTIST);
                    set_TagField(myTag, main_data->disc_title, ID3FID_ALBUM);
                    set_TagField(myTag, main_data->disc_year, ID3FID_YEAR);
                    set_TagField(myTag, s_track_num, ID3FID_TRACKNUM);
                    set_TagField(myTag, main_data->disc_category, ID3FID_CONTENTTYPE);
                    ID3Tag_UpdateByTagType(myTag, ID3TT_ID3V2);
                    ID3Tag_Delete(myTag);
                }
            }

            //dc: strcat() is for sissies!
            sprintf(&buffer[strlen(buffer)], "%d: %s\n", ++tracksdone, file_name_without_path(enc_file));

            // tm: basic playlist support - thanks to Mark Tyler
            if(config.cddb_config.create_playlist == TRUE)
            {
                if(fp_playlist == NULL)
                {
                    sprintf(playlist_filespec, "%s/playlist.m3u", file_path_without_name(enc_file));
                    fp_playlist = fopen(playlist_filespec, "w");
                }

                // if we succeeded above, we can now write to this
                if(fp_playlist != NULL)
                {
                    fprintf(fp_playlist, "%s\n", file_name_without_path(enc_file));
                }
            }
        }

        main_data->track[ i ].make_mp3 = FALSE;
    } /* end loop over all tracks */

    free(s_track_num);

    if((config.cddb_config.create_playlist == TRUE) && (fp_playlist != NULL))
    {
        fclose(fp_playlist);
    }

    /* Generate status message */
    sprintf(status_message, _("Tracks Completed: %2d\n\nArtist: %s\nAlbum: %s\n\n%s"),
            tracksdone, main_data->disc_artist, main_data->disc_title, buffer);

    /* show status pop up */
    if(madewavs)
    {
        status_handler(STAT_FINISH_WAV, status_message);
    }
    else if(mademp3s)
    {
        status_handler(STAT_FINISH_MP3, status_message);
    }

    /* Clear status bar */
    main_window_handler(MW_CLEAR_STATUSBAR, NULL, NULL);

    /* Destroy status widget */
    wm_status_frame_handler(WIDGET_DESTROY, WAV, NULL, NULL);

    /* Create select frame */
    select_frame_handler(WIDGET_CREATE, 0, main_data);
    main_window_handler(MW_MODE_SELECT, NULL, NULL);
}
Esempio n. 2
0
/* Save the ID3 to the file */
void List_SaveID3(HWND hwndApp, HWND hwndList, char *filename)
{
    LV_ITEM lvi;
    ID3ITEM *pItem1;
    int i, items;
    ID3Tag *tag;
    ID3Frame *frame;
    ID3Field *field;
    
    /* Strip the tag first, before completely rewriting it */
    if ((tag = ID3Tag_New()) != NULL)
    {
        ID3Tag_Link(tag, filename);
        ID3Tag_Strip(tag, ID3TT_ALL);
        ID3Tag_Clear(tag);

        if (SendMessage(GetDlgItem(hwndApp, IDC_ID3V2TAG), BM_GETCHECK, 0, 0) == BST_UNCHECKED)
        {
            /* No frames saved */
            ID3Tag_Delete(tag);
            EnableWindow(GetDlgItem(hwndApp, IDC_ID3V2TAG), FALSE);
            ListView_DeleteAllItems(hwndList);
            return;
        }

        /* First get the number of items */
        items = ListView_GetItemCount(hwndList);

        if (items > 0)
        {
            for (i = 0; i < items; i++)
            {
                lvi.mask = LVIF_PARAM;
                lvi.iItem = i;
                lvi.iSubItem = 0;

                if (ListView_GetItem(hwndList, &lvi) == TRUE)
                {
                    pItem1 = (ID3ITEM*)lvi.lParam;

                    frame = ID3Frame_NewID(pItem1->frameId);

                    switch (pItem1->frameId)
                    {
                    case ID3FID_ALBUM:            case ID3FID_BPM:
                    case ID3FID_COMPOSER:         case ID3FID_CONTENTTYPE:
                    case ID3FID_COPYRIGHT:        case ID3FID_DATE:
                    case ID3FID_PLAYLISTDELAY:    case ID3FID_ENCODEDBY:
                    case ID3FID_LYRICIST:         case ID3FID_FILETYPE:
                    case ID3FID_TIME:             case ID3FID_CONTENTGROUP:
                    case ID3FID_TITLE:            case ID3FID_SUBTITLE:
                    case ID3FID_INITIALKEY:       case ID3FID_LANGUAGE:
                    case ID3FID_SONGLEN:          case ID3FID_MEDIATYPE:
                    case ID3FID_ORIGALBUM:        case ID3FID_ORIGFILENAME:
                    case ID3FID_ORIGLYRICIST:     case ID3FID_ORIGARTIST:
                    case ID3FID_ORIGYEAR:         case ID3FID_FILEOWNER:
                    case ID3FID_LEADARTIST:       case ID3FID_BAND:
                    case ID3FID_CONDUCTOR:        case ID3FID_MIXARTIST:
                    case ID3FID_PARTINSET:        case ID3FID_PUBLISHER:
                    case ID3FID_TRACKNUM:         case ID3FID_RECORDINGDATES:
                    case ID3FID_NETRADIOSTATION:  case ID3FID_NETRADIOOWNER:
                    case ID3FID_SIZE:             case ID3FID_ISRC:
                    case ID3FID_ENCODERSETTINGS:  case ID3FID_YEAR:
                    {
                        field = ID3Frame_GetField(frame, ID3FN_TEXT);
                        ID3Field_SetASCII(field, pItem1->aCols[1]);
                        ID3Tag_AddFrame(tag, frame);
                        break;
                    }
                    case ID3FID_USERTEXT:
                    case ID3FID_COMMENT: /* Can also contain an extra language field (but not used now) */
                    case ID3FID_UNSYNCEDLYRICS: /* Can also contain an extra language field (but not used now) */
                    {
                        field = ID3Frame_GetField(frame, ID3FN_DESCRIPTION);
                        ID3Field_SetASCII(field, pItem1->aCols[0]);
                        field = ID3Frame_GetField(frame, ID3FN_TEXT);
                        ID3Field_SetASCII(field, pItem1->aCols[1]);
                        ID3Tag_AddFrame(tag, frame);
                        break;
                    }
                    case ID3FID_WWWAUDIOFILE:     case ID3FID_WWWARTIST:
                    case ID3FID_WWWAUDIOSOURCE:   case ID3FID_WWWCOMMERCIALINFO:
                    case ID3FID_WWWCOPYRIGHT:     case ID3FID_WWWPUBLISHER:
                    case ID3FID_WWWPAYMENT:       case ID3FID_WWWRADIOPAGE:
                    {
                        field = ID3Frame_GetField(frame, ID3FN_URL);
                        ID3Field_SetASCII(field, pItem1->aCols[1]);
                        ID3Tag_AddFrame(tag, frame);
                        break;
                    }
                    case ID3FID_WWWUSER:
                    {
                        field = ID3Frame_GetField(frame, ID3FN_DESCRIPTION);
                        ID3Field_SetASCII(field, pItem1->aCols[0]);
                        field = ID3Frame_GetField(frame, ID3FN_URL);
                        ID3Field_SetASCII(field, pItem1->aCols[1]);
                        ID3Tag_AddFrame(tag, frame);
                        break;
                    }
                    default:
                        break;
                    }
                }
            }
            ID3Tag_UpdateByTagType(tag, ID3TT_ID3V2);
        }

        ID3Tag_Delete(tag);
    }
}