コード例 #1
0
ファイル: Tag_Mp4.cpp プロジェクト: k-takata/mp3infp
DWORD CTag_Mp4::Save(LPCTSTR szFileName)
{
    DWORD dwWin32errorCode = ERROR_SUCCESS;
    if(!m_bEnable)
    {
        return -1;
    }

    char *pFileName = TstrToDataAlloc(szFileName, -1, NULL, DTC_CODE_UTF8);
    if (pFileName == NULL) {
        return -1;
    }
    MP4FileHandle mp4file = MP4Modify(pFileName);
    free(pFileName);
    if(mp4file == MP4_INVALID_FILE_HANDLE)
    {
        return -1;
    }

#ifdef USE_OLD_TAG_API
    if(m_strMetadata_Name.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Name, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataName(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataName(mp4file);
    }

    if(m_strMetadata_Artist.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Artist, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataArtist(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataArtist(mp4file);
    }

    if(m_strMetadata_Album.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Album, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataAlbum(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataAlbum(mp4file);
    }

    if(m_strMetadata_Group.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Group, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataGrouping(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataGrouping(mp4file);
    }

    if(m_strMetadata_Composer.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Composer, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataWriter(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataWriter(mp4file);
    }

    if(m_strMetadata_Genre.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Genre, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataGenre(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataGenre(mp4file);
    }

    if((m_iMetadata_Track1 == -1) && (m_iMetadata_Track2 == -1))
    {
        MP4DeleteMetadataTrack(mp4file);
    }
    else if(m_iMetadata_Track1 == -1)
    {
        MP4SetMetadataTrack(mp4file,0,m_iMetadata_Track2);
    }
    else if(m_iMetadata_Track2 == -1)
    {
        MP4SetMetadataTrack(mp4file,m_iMetadata_Track1,0);
    }
    else
    {
        MP4SetMetadataTrack(mp4file,m_iMetadata_Track1,m_iMetadata_Track2);
    }

    if((m_iMetadata_Disc1 == -1) && (m_iMetadata_Disc2 == -1))
    {
        MP4DeleteMetadataDisk(mp4file);
    }
    else if(m_iMetadata_Disc1 == -1)
    {
        MP4SetMetadataDisk(mp4file,0,m_iMetadata_Disc2);
    }
    else if(m_iMetadata_Disc2 == -1)
    {
        MP4SetMetadataDisk(mp4file,m_iMetadata_Disc1,0);
    }
    else
    {
        MP4SetMetadataDisk(mp4file,m_iMetadata_Disc1,m_iMetadata_Disc2);
    }

    if(m_iMetadata_Tempo == -1)
    {
        MP4DeleteMetadataTempo(mp4file);
    }
    else
    {
        MP4SetMetadataTempo(mp4file,m_iMetadata_Tempo);
    }

    if(m_strMetadata_Year.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Year, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataYear(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataYear(mp4file);
    }

    if(m_iMetadata_Compilation != -1)
    {
        MP4SetMetadataCompilation(mp4file,1);
    }
    else
    {
        MP4DeleteMetadataCompilation(mp4file);
    }

    if(m_strMetadata_Comment.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Comment, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataComment(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataComment(mp4file);
    }

    if(m_strMetadata_Tool.GetLength())
    {
        char *buf = TstrToDataAlloc(m_strMetadata_Tool, -1, NULL, DTC_CODE_UTF8);
        if (buf != NULL) {
            MP4SetMetadataTool(mp4file,buf);
            free(buf);
        }
    }
    else
    {
        MP4DeleteMetadataTool(mp4file);
    }
#else
    const MP4Tags* tags = MP4TagsAlloc();

    if(tags)
    {
        MP4TagsFetch(tags, mp4file);

        if(m_strMetadata_Name.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Name, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetName(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetName(tags, NULL);
        }

        if(m_strMetadata_Artist.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Artist, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetArtist(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetArtist(tags, NULL);
        }

        if(m_strMetadata_Album.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Album, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetAlbum(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetAlbum(tags, NULL);
        }

        if(m_strMetadata_Group.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Group, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetGrouping(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetGrouping(tags, NULL);
        }

        if(m_strMetadata_Composer.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Composer, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetComposer(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetComposer(tags, NULL);
        }

        if(m_strMetadata_Genre.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Genre, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetGenre(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetGenre(tags, NULL);
        }

        if((m_iMetadata_Track1 == -1) && (m_iMetadata_Track2 == -1))
        {
            MP4TagsSetTrack(tags, NULL);
        }
        else
        {
            MP4TagTrack track;
            track.index = (m_iMetadata_Track1 == -1) ? 0 : m_iMetadata_Track1;
            track.total = (m_iMetadata_Track2 == -1) ? 0 : m_iMetadata_Track2;
            MP4TagsSetTrack(tags, &track);
        }

        if((m_iMetadata_Disc1 == -1) && (m_iMetadata_Disc2 == -1))
        {
            MP4TagsSetDisk(tags, NULL);
        }
        else
        {
            MP4TagDisk disk;
            disk.index = (m_iMetadata_Disc1 == -1) ? 0 : m_iMetadata_Disc1;
            disk.total = (m_iMetadata_Disc2 == -1) ? 0 : m_iMetadata_Disc2;
            MP4TagsSetDisk(tags, &disk);
        }

        if(m_iMetadata_Tempo == -1)
        {
            MP4TagsSetTempo(tags, NULL);
        }
        else
        {
            uint16_t tempo = m_iMetadata_Tempo;
            MP4TagsSetTempo(tags, &tempo);
        }

        if(m_strMetadata_Year.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Year, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetReleaseDate(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetReleaseDate(tags, NULL);
        }

        if(m_iMetadata_Compilation != -1)
        {
            uint8_t compilation = 1;
            MP4TagsSetCompilation(tags, &compilation);
        }
        else
        {
            MP4TagsSetCompilation(tags, NULL);
        }

        if(m_strMetadata_Comment.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Comment, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetComments(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetComments(tags, NULL);
        }

        if(m_strMetadata_Tool.GetLength())
        {
            char *buf = TstrToDataAlloc(m_strMetadata_Tool, -1, NULL, DTC_CODE_UTF8);
            if (buf != NULL) {
                MP4TagsSetEncodingTool(tags, buf);
                free(buf);
            }
        }
        else
        {
            MP4TagsSetEncodingTool(tags, NULL);
        }

        MP4TagsStore(tags, mp4file);
        MP4TagsFree(tags);
    }
#endif

    MP4Close(mp4file);

    return dwWin32errorCode;
}
コード例 #2
0
DWORD CM3u::Save(LPCTSTR szFileName)
{
	DWORD	dwWin32errorCode = ERROR_SUCCESS;

	if (lstrcmpi(getExtName(szFileName), _T(".m3u8")) == 0) {
		if ((m_encoding != ENC_UTF8N) && (m_encoding != ENC_UTF8B)) {
			m_encoding = ENC_UTF8N;
		}
	}
	int output_code = DTC_CODE_ANSI;
	if ((m_encoding == ENC_UTF8N) || (m_encoding == ENC_UTF8B)) {
		output_code = DTC_CODE_UTF8;
	}

	//ファイルをオープン
	HANDLE hFile = CreateFile(
							szFileName,
							GENERIC_READ|GENERIC_WRITE,
							FILE_SHARE_READ,
							NULL,
							CREATE_ALWAYS,	//新しいファイルを作成します。指定したファイルが既に存在している場合、そのファイルを上書きし、既存の属性を消去します。
							FILE_ATTRIBUTE_NORMAL,
							NULL);
	if(hFile == INVALID_HANDLE_VALUE)
	{
		dwWin32errorCode = GetLastError();
		return dwWin32errorCode;
	}

	DWORD dwWritten;
	if (m_encoding == ENC_UTF8B) {
		WriteFile(hFile, "\xEF\xBB\xBF", 3, &dwWritten, NULL);
	}

	//リストが空の時は0バイトのファイルを作る
	if(m_strLines.GetUpperBound() == -1)
	{
		CloseHandle(hFile);
		return dwWin32errorCode;
	}

	CString str;
	for(int i=0; i<=m_strLines.GetUpperBound(); i++)
	{
		str = m_strLines.GetAt(i);
		str += _T("\r\n");
		int size;
		char *buf = TstrToDataAlloc(str, str.GetLength(), &size, output_code);
		if (buf != NULL) {
			int ret = WriteFile(hFile,buf,size,&dwWritten,NULL);
			free(buf);
			if (!ret) {
				dwWin32errorCode = GetLastError();
				break;
			}
		}
	}
	CloseHandle(hFile);
	
	return dwWin32errorCode;
}
コード例 #3
0
ファイル: Tag_Mp4.cpp プロジェクト: k-takata/mp3infp
DWORD CTag_Mp4::Load(LPCTSTR szFileName)
{
    DWORD dwWin32errorCode = ERROR_SUCCESS;
    Release();

    char *pFileName = TstrToDataAlloc(szFileName, -1, NULL, DTC_CODE_UTF8);
    if (pFileName == NULL) {
        return -1;
    }
    char *info = MP4FileInfo(pFileName);
    if(!info)
    {
        free(pFileName);
        Release();
        return -1;
    }
    m_strTrackInfo = info;
    free(info);
    m_strTrackInfo.Replace(_T("\n"),_T("\r\n"));

    // Audio/Video
    _StripAudioInfo(m_strTrackInfo,m_strAudioInfo,m_strVideoInfo);

    MP4FileHandle mp4file = MP4Read(pFileName);
    free(pFileName);
    if(mp4file == MP4_INVALID_FILE_HANDLE)
    {
        Release();
        return -1;
    }

    m_bEnable = TRUE;
    char *value;
    uint16_t numvalue, numvalue2;
    uint8_t int8value;

#ifdef USE_OLD_TAG_API
    if(MP4GetMetadataName(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Name = _CnvMetadata(value);
    }

    if(MP4GetMetadataArtist(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Artist = _CnvMetadata(value);
    }

    if(MP4GetMetadataAlbum(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Album = _CnvMetadata(value);
    }

    if(MP4GetMetadataGrouping(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Group = _CnvMetadata(value);
    }

    if(MP4GetMetadataWriter(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Composer = _CnvMetadata(value);
    }

    if(MP4GetMetadataGenre(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Genre = _CnvMetadata(value);
    }

    if(MP4GetMetadataTrack(mp4file,&numvalue,&numvalue2))
    {
        m_iMetadata_Track1 = numvalue;
        m_iMetadata_Track2 = numvalue2;
    }

    if(MP4GetMetadataDisk(mp4file,&numvalue,&numvalue2))
    {
        m_iMetadata_Disc1 = numvalue;
        m_iMetadata_Disc2 = numvalue2;
    }

    if(MP4GetMetadataTempo(mp4file,&numvalue))
    {
        m_iMetadata_Tempo = numvalue;
    }

    if(MP4GetMetadataYear(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Year = _CnvMetadata(value);
    }

    if(MP4GetMetadataCompilation(mp4file,&int8value))
    {
        m_iMetadata_Compilation = int8value;
    }

    if(MP4GetMetadataComment(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Comment = _CnvMetadata(value);
    }

    if(MP4GetMetadataTool(mp4file,&value) && (value != NULL))
    {
        m_strMetadata_Tool = _CnvMetadata(value);
    }
#else
    const MP4Tags* tags = MP4TagsAlloc();

    if(tags)
    {
        MP4TagsFetch(tags, mp4file);

        if(tags->name)
        {
            m_strMetadata_Name = _CnvMetadata(tags->name);
        }

        if(tags->artist)
        {
            m_strMetadata_Artist = _CnvMetadata(tags->artist);
        }

        if(tags->album)
        {
            m_strMetadata_Album = _CnvMetadata(tags->album);
        }

        if(tags->grouping)
        {
            m_strMetadata_Group = _CnvMetadata(tags->grouping);
        }

        if(tags->composer)
        {
            m_strMetadata_Composer = _CnvMetadata(tags->composer);
        }

        if(tags->genre)
        {
            m_strMetadata_Genre = _CnvMetadata(tags->genre);
        }

        if(tags->track)
        {
            m_iMetadata_Track1 = tags->track->index;
            m_iMetadata_Track2 = tags->track->total;
        }

        if(tags->disk)
        {
            m_iMetadata_Disc1 = tags->disk->index;
            m_iMetadata_Disc2 = tags->disk->total;
        }

        if(tags->tempo)
        {
            m_iMetadata_Tempo = *tags->tempo;
        }

        if(tags->releaseDate)
        {
            m_strMetadata_Year = _CnvMetadata(tags->releaseDate);
        }

        if(tags->compilation)
        {
            m_iMetadata_Compilation = *tags->compilation;
        }

        if(tags->comments)
        {
            m_strMetadata_Comment = _CnvMetadata(tags->comments);
        }

        if(tags->encodingTool)
        {
            m_strMetadata_Tool = _CnvMetadata(tags->encodingTool);
        }

        MP4TagsFree(tags);
    }
#endif

    MP4Close(mp4file);

    return dwWin32errorCode;
}