ref: 2108cdfee01328b35c50d8f260870c661d5d2711
parent: 8498be7f35f42ef1d32c4de67428dbf05a6057bf
author: aforanna <aforanna>
date: Mon Oct 25 17:53:54 EDT 2004
no message
binary files /dev/null b/common/Cfaac/AudioCoding.bmp differ
--- /dev/null
+++ b/common/Cfaac/CRegistry.cpp
@@ -1,0 +1,361 @@
+/*
+CRegistry class
+Copyright (C) 2002-2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include "CRegistry.h"
+
+//************************************************************************************************
+
+CRegistry::CRegistry()
+{
+ regKey=NULL;
+ path=NULL;
+}
+//------------------------------------------------------------------------------------------------
+
+CRegistry::~CRegistry()
+{
+ Close();
+}
+//************************************************************************************************
+/*
+void CRegistry::ShowLastError(char *Caption)
+{
+LPVOID MsgBuf;
+ if(FormatMessage(
+ FORMAT_MESSAGE_ALLOCATE_BUFFER |
+ FORMAT_MESSAGE_FROM_SYSTEM |
+ FORMAT_MESSAGE_IGNORE_INSERTS,
+ NULL,
+ GetLastError(),
+ MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
+ (LPTSTR) &MsgBuf,
+ 0,
+ NULL
+ ))
+ MessageBox(NULL, (LPCTSTR)MsgBuf, Caption, MB_OK|MB_ICONSTOP);
+ if(MsgBuf)
+ LocalFree(MsgBuf);
+}*/
+//************************************************************************************************
+
+#define setPath(SubKey) \
+{ \
+ if(path) \
+ free(path); \
+ path=strdup(SubKey); \
+}
+
+BOOL CRegistry::Open(HKEY hKey, char *SubKey)
+{
+ if(regKey)
+ RegCloseKey(regKey);
+ if(RegOpenKeyEx(hKey, SubKey, 0, KEY_ALL_ACCESS, ®Key)==ERROR_SUCCESS)
+ {
+ setPath(SubKey);
+ return TRUE;
+ }
+ else // can't open the key -> error
+ {
+ regKey=0;
+ setPath("");
+ return FALSE;
+ }
+}
+//************************************************************************************************
+
+BOOL CRegistry::OpenCreate(HKEY hKey, char *SubKey)
+{
+ if(regKey)
+ RegCloseKey(regKey);
+ if(RegOpenKeyEx(hKey, SubKey, 0, KEY_ALL_ACCESS, ®Key)==ERROR_SUCCESS)
+ {
+ setPath(SubKey);
+ return TRUE;
+ }
+ else // open failed -> create the key
+ {
+ DWORD disp;
+ RegCreateKeyEx(hKey, SubKey, 0, NULL, REG_OPTION_NON_VOLATILE, KEY_ALL_ACCESS, NULL, ®Key, &disp);
+ if(disp==REG_CREATED_NEW_KEY)
+ {
+ setPath(SubKey);
+ return TRUE;
+ }
+ else // can't create the key -> error
+ {
+ regKey=0;
+ setPath("");
+ return FALSE;
+ }
+ }
+}
+//************************************************************************************************
+
+void CRegistry::Close()
+{
+ if(regKey)
+ RegCloseKey(regKey);
+ regKey=NULL;
+ if(path)
+ free(path);
+ path=NULL;
+}
+//************************************************************************************************
+//************************************************************************************************
+//************************************************************************************************
+
+void CRegistry::DeleteVal(char *SubKey)
+{
+ RegDeleteValue(regKey,SubKey);
+}
+//************************************************************************************************
+
+void CRegistry::DeleteKey(char *SubKey)
+{
+ RegDeleteKey(regKey,SubKey);
+}
+
+//************************************************************************************************
+//************************************************************************************************
+//************************************************************************************************
+
+void CRegistry::SetBool(char *keyStr, bool val)
+{
+bool tempVal;
+DWORD len=sizeof(bool);
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS ||
+ tempVal!=val)
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, (BYTE *)&val, sizeof(bool));
+}
+//************************************************************************************************
+
+void CRegistry::SetByte(char *keyStr, BYTE val)
+{
+DWORD t=val;
+DWORD tempVal;
+DWORD len;
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS ||
+ tempVal!=val)
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&t, sizeof(DWORD));
+}
+//************************************************************************************************
+
+void CRegistry::SetWord(char *keyStr, WORD val)
+{
+DWORD t=val;
+DWORD tempVal;
+DWORD len;
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS ||
+ tempVal!=val)
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&t, sizeof(DWORD));
+}
+//************************************************************************************************
+
+void CRegistry::SetDword(char *keyStr, DWORD val)
+{
+DWORD tempVal;
+DWORD len;
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS ||
+ tempVal!=val)
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&val, sizeof(DWORD));
+}
+//************************************************************************************************
+
+void CRegistry::SetFloat(char *keyStr, float val)
+{
+float tempVal;
+DWORD len;
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS ||
+ tempVal!=val)
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, (BYTE *)&val, sizeof(float));
+}
+//************************************************************************************************
+
+void CRegistry::SetStr(char *keyStr, char *valStr)
+{
+DWORD len;
+DWORD slen=strlen(valStr)+1;
+
+ if(!valStr || !*valStr)
+ return;
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, NULL, &len )!=ERROR_SUCCESS ||
+ len!=slen)
+ RegSetValueEx(regKey, keyStr, 0, REG_SZ, (BYTE *)valStr, slen);
+ else
+ {
+ char *tempVal=new char[slen];
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)tempVal, &len )!=ERROR_SUCCESS ||
+ strcmpi(tempVal,valStr))
+ RegSetValueEx(regKey, keyStr, 0, REG_SZ, (BYTE *)valStr, slen);
+ delete tempVal;
+ }
+}
+//************************************************************************************************
+
+void CRegistry::SetValN(char *keyStr, BYTE *addr, DWORD size)
+{
+DWORD len;
+ if(!addr || !size)
+ return;
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, NULL, &len )!=ERROR_SUCCESS ||
+ len!=size)
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, addr, size);
+ else
+ {
+ BYTE *tempVal=new BYTE[size];
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)tempVal, &len )!=ERROR_SUCCESS ||
+ memcmp(tempVal,addr,len))
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, addr, size);
+ delete tempVal;
+ }
+}
+
+
+
+//************************************************************************************************
+//************************************************************************************************
+//************************************************************************************************
+
+
+
+bool CRegistry::GetSetBool(char *keyStr, bool val)
+{
+bool tempVal;
+DWORD len=sizeof(bool);
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS)
+ {
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, (BYTE *)&val, sizeof(bool));
+ return val;
+ }
+ return tempVal;
+}
+//************************************************************************************************
+
+BYTE CRegistry::GetSetByte(char *keyStr, BYTE val)
+{
+DWORD tempVal;
+DWORD len=sizeof(DWORD);
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS)
+ {
+ tempVal=val;
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&tempVal, sizeof(DWORD));
+ return val;
+ }
+ return (BYTE)tempVal;
+}
+//************************************************************************************************
+
+WORD CRegistry::GetSetWord(char *keyStr, WORD val)
+{
+DWORD tempVal;
+DWORD len=sizeof(DWORD);
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS)
+ {
+ tempVal=val;
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&tempVal, sizeof(DWORD));
+ return val;
+ }
+ return (WORD)tempVal;
+}
+//************************************************************************************************
+
+DWORD CRegistry::GetSetDword(char *keyStr, DWORD val)
+{
+DWORD tempVal;
+DWORD len=sizeof(DWORD);
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS)
+ {
+ RegSetValueEx(regKey, keyStr, 0, REG_DWORD, (BYTE *)&val, sizeof(DWORD));
+ return val;
+ }
+ return (DWORD)tempVal;
+}
+//************************************************************************************************
+
+float CRegistry::GetSetFloat(char *keyStr, float val)
+{
+float tempVal;
+DWORD len=sizeof(float);
+
+ if(RegQueryValueEx(regKey, keyStr, NULL, NULL, (BYTE *)&tempVal, &len )!=ERROR_SUCCESS)
+ {
+ RegSetValueEx(regKey, keyStr, 0, REG_BINARY, (BYTE *)&val, sizeof(float));
+ return val;
+ }
+ return tempVal;
+}
+//************************************************************************************************
+
+char *CRegistry::GetSetStr(char *keyStr, char *String)
+{
+long retVal;
+DWORD Len;
+char *dest=NULL;
+
+ if((retVal=RegQueryValueEx(regKey , keyStr , NULL , NULL, NULL, &Len))==ERROR_SUCCESS)
+ if(dest=(char *)malloc(Len+1))
+ retVal=RegQueryValueEx(regKey , keyStr , NULL , NULL, (BYTE *)dest , &Len);
+ if(retVal!=ERROR_SUCCESS)
+ {
+ if(dest)
+ free(dest);
+ if(!String)
+ return NULL;
+
+ Len=strlen(String)+1;
+ if(!(dest=strdup(String)))
+ return NULL;
+ RegSetValueEx(regKey , keyStr , NULL , REG_SZ , (BYTE *)dest , Len);
+ }
+ return dest;
+}
+// -----------------------------------------------------------------------------------------------
+
+int CRegistry::GetSetValN(char *keyStr, BYTE *defData, DWORD defSize, BYTE **dest)
+{
+long retVal;
+DWORD size;
+
+ dest=NULL;
+ if((retVal=RegQueryValueEx(regKey , keyStr , NULL , NULL, NULL, &size))==ERROR_SUCCESS)
+ if(*dest=(BYTE *)malloc(size+1))
+ retVal=RegQueryValueEx(regKey , keyStr , NULL , NULL, (BYTE *)*dest , &size);
+ if(retVal!=ERROR_SUCCESS)
+ {
+ if(dest)
+ free(dest);
+ if(!defData)
+ return 0;
+
+ size=defSize;
+ if(!(*dest=(BYTE *)malloc(size)))
+ return 0;
+ memcpy(*dest,defData,size);
+ RegSetValueEx(regKey , keyStr , NULL , REG_BINARY , (BYTE *)*dest , size);
+ }
+ return size;
+}
--- /dev/null
+++ b/common/Cfaac/CRegistry.h
@@ -1,0 +1,64 @@
+/*
+CRegistry class
+Copyright (C) 2002-2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+//---------------------------------------------------------------------------
+#ifndef CRegistryH
+#define CRegistryH
+//---------------------------------------------------------------------------
+
+#include <windows.h>
+#include <stdlib.h>
+#include <string.h>
+//#include <memory.h>
+
+class CRegistry
+{
+public:
+ CRegistry();
+ ~CRegistry();
+
+ BOOL Open(HKEY hKey, char *SubKey);
+ BOOL OpenCreate(HKEY hKey, char *SubKey);
+ void Close();
+ void DeleteVal(char *SubKey);
+ void DeleteKey(char *SubKey);
+
+ void SetBool(char *keyStr , bool val);
+ void SetByte(char *keyStr , BYTE val);
+ void SetWord(char *keyStr , WORD val);
+ void SetDword(char *keyStr , DWORD val);
+ void SetFloat(char *keyStr , float val);
+ void SetStr(char *keyStr , char *valStr);
+ void SetValN(char *keyStr , BYTE *addr, DWORD size);
+
+ bool GetSetBool(char *keyStr, bool var);
+ BYTE GetSetByte(char *keyStr, BYTE var);
+ WORD GetSetWord(char *keyStr, WORD var);
+ DWORD GetSetDword(char *keyStr, DWORD var);
+ float GetSetFloat(char *keyStr, float var);
+ char *GetSetStr(char *keyStr, char *String);
+ int GetSetValN(char *keyStr, BYTE *defData, DWORD defSize, BYTE **dest);
+
+ HKEY regKey;
+ char *path;
+};
+
+#endif
--- /dev/null
+++ b/common/Cfaac/CTag.cpp
@@ -1,0 +1,346 @@
+/*
+CTag - Class to read/write id3v2/mp4 tags
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include <stdlib.h>
+#include <mp4.h>
+#include <faac.h>
+#include "CTag.h"
+
+
+
+// *********************************************************************************************
+// CMP4Tag
+// *********************************************************************************************
+
+CMP4Tag::CMP4Tag()
+{
+// memset(this,0,sizeof(*this));
+ copyright=NULL;
+ artist=title=album=year=genre=writer=comment=NULL;
+ trackno=ntracks=discno=ndiscs=0;
+ compilation=0;
+ artFilename=NULL;
+ art.pictureType=0; // = other
+ memset(&art,0,sizeof(art));
+}
+// *********************************************************************************************
+
+void CMP4Tag::FreeTag()
+{
+ FREE_ARRAY(artist);
+ FREE_ARRAY(title);
+ FREE_ARRAY(album);
+ FREE_ARRAY(year);
+ FREE_ARRAY(genre);
+ FREE_ARRAY(writer);
+ FREE_ARRAY(comment);
+ FREE_ARRAY(artFilename);
+ FREE_ARRAY(art.data);
+ FREE_ARRAY(art.description);
+ FREE_ARRAY(art.mimeType);
+ FREE_ARRAY(art.format);
+}
+// ***********************************************************************************************
+
+int CMP4Tag::check_image_header(const char *buf)
+{
+ if(!strncmp(buf, "\x89\x50\x4E\x47\x0D\x0A\x1A\x0A", 8))
+ return 1; /* PNG */
+ if(!strncmp(buf, "\xFF\xD8\xFF\xE0", 4) &&
+ !strncmp(buf + 6, "JFIF\0", 5))
+ return 2; /* JPEG */
+ if(!strncmp(buf, "GIF87a", 6) || !strncmp(buf, "GIF89a", 6))
+ return 3; /* GIF */
+
+ return 0;
+}
+// -----------------------------------------------------------------------------------------------
+
+int CMP4Tag::ReadCoverArtFile(char *pCoverArtFile, char **artData)
+{
+FILE *artFile;
+
+ if(!pCoverArtFile || !*pCoverArtFile)
+ return 0;
+
+ if(!(artFile=fopen(pCoverArtFile, "rb")))
+ {
+ char buf[25+MAX_PATH+1];
+ sprintf(buf,"ReadCoverArtFile: can't open \"%s\"",pCoverArtFile);
+ MessageBox(NULL,buf,NULL,MB_OK);
+ return 0;
+ }
+
+int r;
+char *art;
+int artSize=0;
+
+ fseek(artFile, 0, SEEK_END);
+ artSize=ftell(artFile);
+ fseek(artFile, 0, SEEK_SET);
+
+ if(!(art=(char *)malloc(artSize)))
+ {
+ fclose(artFile);
+ MessageBox(NULL,"ReadCoverArtFile: Memory allocation error!", NULL, MB_OK);
+ return 0;
+ }
+
+ r=fread(art, 1, artSize, artFile);
+ if(r!=artSize)
+ {
+ free(art);
+ fclose(artFile);
+ MessageBox(NULL,"ReadCoverArtFile: Error reading cover art file!", NULL, MB_OK);
+ return 0;
+ }
+ else
+ if(artSize<12 || !check_image_header(art))
+ {
+ // the above expression checks the image signature
+ free(art);
+ fclose(artFile);
+ MessageBox(NULL,"ReadCoverArtFile: Unsupported cover image file format!", NULL, MB_OK);
+ return 0;
+ }
+
+ FREE_ARRAY(*artData);
+ *artData=art;
+ fclose(artFile);
+ return artSize;
+}
+// *********************************************************************************************
+
+int CMP4Tag::WriteMP4Tag(MP4FileHandle MP4File)
+{
+char buf[512], *faac_id_string, *faac_copyright_string;
+
+ if(MP4File==NULL)
+ {
+ MessageBox(NULL,"WriteMp4Tag: can't open file!",NULL,MB_OK);
+ return 1;
+ }
+
+ sprintf(buf, "FAAC v%s", (faacEncGetVersion(&faac_id_string, &faac_copyright_string)==FAAC_CFG_VERSION) ? faac_id_string : " wrong libfaac version");
+ MP4SetMetadataTool(MP4File, buf);
+
+ if(artist) MP4SetMetadataArtist(MP4File, artist);
+ if(writer) MP4SetMetadataWriter(MP4File, writer);
+ if(title) MP4SetMetadataName(MP4File, title);
+ if(album) MP4SetMetadataAlbum(MP4File, album);
+ if(trackno>0) MP4SetMetadataTrack(MP4File, trackno, ntracks);
+ if(discno>0) MP4SetMetadataDisk(MP4File, discno, ndiscs);
+ if(compilation) MP4SetMetadataCompilation(MP4File, compilation);
+ if(year) MP4SetMetadataYear(MP4File, year);
+ if(genre) MP4SetMetadataGenre(MP4File, genre);
+ if(comment) MP4SetMetadataComment(MP4File, comment);
+ if(art.size=ReadCoverArtFile(artFilename,&art.data))
+ {
+ MP4SetMetadataCoverArt(MP4File, (unsigned __int8 *)art.data, art.size);
+ FREE_ARRAY(art.data);
+ }
+ return 0;
+}
+// *********************************************************************************************
+
+int CMP4Tag::ReadMp4Tag(char *Filename)
+{
+MP4FileHandle MP4File;
+
+ if(!(MP4File=MP4Read(Filename, 0)))
+ {
+ char buf[25+MAX_PATH+1];
+ sprintf(buf,"ReadMp4Tag: can't open \"%s\"",Filename);
+ MessageBox(NULL,buf,NULL,MB_OK);
+ return 1;
+ }
+
+ FREE_ARRAY(copyright);
+ MP4GetMetadataTool(MP4File, ©right);
+
+ FREE_ARRAY(artist);
+ MP4GetMetadataArtist(MP4File, &artist);
+ FREE_ARRAY(writer);
+ MP4GetMetadataWriter(MP4File, &writer);
+ FREE_ARRAY(title);
+ MP4GetMetadataName(MP4File, &title);
+ FREE_ARRAY(album);
+ MP4GetMetadataAlbum(MP4File, &album);
+ MP4GetMetadataTrack(MP4File, (unsigned __int16 *)&trackno, (unsigned __int16 *)&ntracks);
+ MP4GetMetadataDisk(MP4File, (unsigned __int16 *)&discno, (unsigned __int16 *)&ndiscs);
+ MP4GetMetadataCompilation(MP4File, (unsigned __int8 *)&compilation);
+ FREE_ARRAY(year);
+ MP4GetMetadataYear(MP4File, &year);
+ FREE_ARRAY(genre);
+ MP4GetMetadataGenre(MP4File, &genre);
+ FREE_ARRAY(comment);
+ MP4GetMetadataComment(MP4File, &comment);
+ FREE_ARRAY(art.data);
+ MP4GetMetadataCoverArt(MP4File, (unsigned __int8 **)&art.data, (u_int32_t *)&art.size);
+
+ MP4Close(MP4File);
+/*
+ FILE *f=fopen("D:\\prova.jpg","wb");
+ fwrite(artFile,1,artSize,f);
+ fclose(f);*/
+ return 0;
+}
+// *********************************************************************************************
+
+#define DEL_FIELD(id3Tag,ID3FID) \
+{ \
+ID3_Frame *Frame=id3Tag.Find(ID3FID); \
+ if(Frame!=NULL) \
+ id3Tag.RemoveFrame(Frame); \
+}
+// -----------------------------------------------------------------------------------------------
+
+#define ADD_FIELD(id3Tag,ID3FID,ID3FN,data) \
+{ \
+ID3_Frame *NewFrame=new ID3_Frame(ID3FID); \
+ NewFrame->Field(ID3FN)=data; \
+ DEL_FIELD(id3Tag,ID3FID); \
+ id3Tag.AttachFrame(NewFrame); \
+}
+// -----------------------------------------------------------------------------------------------
+
+int CMP4Tag::WriteAacTag(char *Filename)
+{
+char buf[512], *faac_id_string, *faac_copyright_string;
+ID3_Tag id3Tag;
+FILE *file;
+
+ if((file=fopen(Filename,"r"))==NULL)
+ {
+ char buf[25+MAX_PATH+1];
+ sprintf(buf,"WriteAacTag: can't open \"%s\"",Filename);
+ MessageBox(NULL,buf,NULL,MB_OK);
+ return 1;
+ }
+ else
+ fclose(file);
+ id3Tag.Link(Filename);
+
+ sprintf(buf, "FAAC v%s", (faacEncGetVersion(&faac_id_string, &faac_copyright_string)==FAAC_CFG_VERSION) ? faac_id_string : " wrong libfaac version");
+ ADD_FIELD(id3Tag,ID3FID_ENCODEDBY,ID3FN_TEXT,buf);
+
+ ADD_FIELD(id3Tag,ID3FID_LEADARTIST,ID3FN_TEXT,artist);
+ ADD_FIELD(id3Tag,ID3FID_COMPOSER,ID3FN_TEXT,writer);
+ ADD_FIELD(id3Tag,ID3FID_TITLE,ID3FN_TEXT,title);
+ ADD_FIELD(id3Tag,ID3FID_ALBUM,ID3FN_TEXT,album);
+ sprintf(buf,"%d",trackno);
+ ADD_FIELD(id3Tag,ID3FID_TRACKNUM,ID3FN_TEXT,buf);
+ ADD_FIELD(id3Tag,ID3FID_YEAR,ID3FN_TEXT,year);
+ ADD_FIELD(id3Tag,ID3FID_CONTENTTYPE,ID3FN_TEXT,genre);
+ ADD_FIELD(id3Tag,ID3FID_COMMENT,ID3FN_TEXT,comment);
+ art.size=ReadCoverArtFile(artFilename,&art.data);
+ if(art.size)
+ {
+ ID3_Frame *NewFrame=new ID3_Frame(ID3FID_PICTURE);
+ char name[_MAX_FNAME], ext[_MAX_EXT];
+ _splitpath(artFilename,NULL,NULL,name,ext);
+
+ NewFrame->Field(ID3FN_DESCRIPTION)=name;
+ char buf[15];
+ sprintf(buf,"image/%s",check_image_header(art.data)==2 ? "jpeg" : strlwr(ext+1));
+ NewFrame->Field(ID3FN_MIMETYPE)=buf;
+// NewFrame->Field(ID3FN_IMAGEFORMAT)=;
+ NewFrame->Field(ID3FN_PICTURETYPE)=(DWORD)art.pictureType;
+ NewFrame->Field(ID3FN_DATA).Set((BYTE *)art.data,art.size);
+ id3Tag.AttachFrame(NewFrame);
+ }
+
+ // setup all our rendering parameters
+ id3Tag.SetUnsync(false);
+ id3Tag.SetExtendedHeader(true);
+ id3Tag.SetCompression(true);
+ id3Tag.SetPadding(true);
+
+ // write any changes to the file
+ id3Tag.Update();
+
+ FREE_ARRAY(art.data);
+ return 0;
+}
+// *********************************************************************************************
+
+#define GET_FIELD_STR(id3Tag,ID3FID,ID3FN,data) \
+{ \
+ Frame=id3Tag.Find(ID3FID); \
+ if(Frame!=NULL) \
+ { \
+ DWORD size=Frame->Field(ID3FN).Size(); \
+ FREE_ARRAY(data); \
+ if(data=(char *)malloc(size+1)) \
+ Frame->Field(ID3FN).Get(data,size+1); \
+ } \
+ else \
+ FREE_ARRAY(data); \
+}
+// -----------------------------------------------------------------------------------------------
+
+int CMP4Tag::ReadAacTag(char *Filename)
+{
+char *buf=NULL;
+ID3_Tag id3Tag;
+ID3_Frame *Frame;
+
+ if(!id3Tag.Link(Filename))
+ {
+ char buf[25+MAX_PATH+1];
+ sprintf(buf,"ReadAacTag: can't open \"%s\"",Filename);
+ MessageBox(NULL,buf,NULL,MB_OK);
+ return 1;
+ }
+
+ GET_FIELD_STR(id3Tag,ID3FID_ENCODEDBY,ID3FN_TEXT,copyright);
+
+ GET_FIELD_STR(id3Tag,ID3FID_LEADARTIST,ID3FN_TEXT,artist);
+ GET_FIELD_STR(id3Tag,ID3FID_COMPOSER,ID3FN_TEXT,writer);
+ GET_FIELD_STR(id3Tag,ID3FID_TITLE,ID3FN_TEXT,title);
+ GET_FIELD_STR(id3Tag,ID3FID_ALBUM,ID3FN_TEXT,album);
+
+ GET_FIELD_STR(id3Tag,ID3FID_TRACKNUM,ID3FN_TEXT,buf);
+ if(buf)
+ trackno=atoi(buf);
+ FREE_ARRAY(buf);
+ GET_FIELD_STR(id3Tag,ID3FID_YEAR,ID3FN_TEXT,year);
+ GET_FIELD_STR(id3Tag,ID3FID_CONTENTTYPE,ID3FN_TEXT,genre);
+ GET_FIELD_STR(id3Tag,ID3FID_COMMENT,ID3FN_TEXT,comment);
+
+ if(Frame=id3Tag.Find(ID3FID_PICTURE))
+ {
+ art.size=Frame->Field(ID3FN_DATA).Size();
+ FREE_ARRAY(art.data);
+ if(art.data=(char *)malloc(art.size))
+ memcpy(art.data,Frame->Field(ID3FN_DATA).GetBinary(),art.size);
+
+ GET_FIELD_STR(id3Tag,ID3FID_PICTURE,ID3FN_MIMETYPE,art.mimeType);
+ GET_FIELD_STR(id3Tag,ID3FID_PICTURE,ID3FN_DESCRIPTION,art.description);
+ GET_FIELD_STR(id3Tag,ID3FID_PICTURE,ID3FN_IMAGEFORMAT,art.format);
+ art.pictureType=Frame->Field(ID3FN_PICTURETYPE).Get();
+/*
+ FILE *f=fopen("D:\\prova.jpg","wb");
+ fwrite(artFile,1,artSize,f);
+ fclose(f);*/
+ }
+ return 0;
+}
\ No newline at end of file
--- /dev/null
+++ b/common/Cfaac/CTag.h
@@ -1,0 +1,86 @@
+/*
+CTag - Class to read/write id3v2/mp4 tags
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#ifndef _CTag_H
+#define _CTag_H
+
+// *********************************************************************************************
+
+#include <mp4.h>
+#include <id3/tag.h> // id3 tag
+#include "CRegistry.h"
+#include "Defines.h"
+
+// *********************************************************************************************
+
+#define REG_TAGON "Tag On"
+#define REG_TAGIMPORT "Tag import"
+#define REG_ARTIST "Tag Artist"
+#define REG_TITLE "Tag Title"
+#define REG_ALBUM "Tag Album"
+#define REG_YEAR "Tag Year"
+#define REG_GENRE "Tag Genre"
+#define REG_WRITER "Tag Writer"
+#define REG_COMMENT "Tag Comment"
+#define REG_TRACK "Tag Track"
+#define REG_NTRACKS "Tag Tracks"
+#define REG_DISK "Tag Disk"
+#define REG_NDISKS "Tag Disks"
+#define REG_COMPILATION "Tag Compilation"
+#define REG_ARTFILE "Tag Art file"
+
+// *********************************************************************************************
+
+typedef struct
+{
+ char *data;
+ DWORD size;
+ DWORD pictureType; // front, back, icon, ...
+ char *mimeType, // jpg, png, gif
+ *format, // ???
+ *description; // text description
+} id3Picture;
+
+class CMP4Tag
+{
+private:
+ int check_image_header(const char *buf);
+ int ReadCoverArtFile(char *pCoverArtFile, char **artBuf);
+
+public:
+ CMP4Tag();
+ virtual ~CMP4Tag() { FreeTag(); }
+
+ virtual void FreeTag();
+ virtual int WriteMP4Tag(MP4FileHandle MP4File);
+ virtual int WriteAacTag(char *Filename);
+ virtual int ReadMp4Tag(char *Filename);
+ virtual int ReadAacTag(char *Filename);
+
+ char *copyright; // used in Cfaad
+ char *artist, *title, *album, *year, *genre, *writer, *comment;
+ WORD trackno,ntracks, discno,ndiscs;
+ BYTE compilation;
+ char *artFilename;
+ id3Picture art; // used in ReadAacTag(). Remark: field not stored into registry
+};
+
+#endif
\ No newline at end of file
--- /dev/null
+++ b/common/Cfaac/Cfaac.cpp
@@ -1,0 +1,719 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include "Cfaac.h"
+
+
+
+// *********************************************************************************************
+// CMyEncCfg
+// *********************************************************************************************
+
+void CMyEncCfg::getCfg(CMyEncCfg *cfg)
+{
+CRegistry reg;
+
+ if(reg.OpenCreate(HKEY_CURRENT_USER, REGISTRY_PROGRAM_NAME "\\FAAC"))
+ {
+ cfg->AutoCfg=reg.GetSetBool(REG_AUTO,DEF_AUTO);
+ cfg->SaveMP4=reg.GetSetByte(REG_WRITEMP4,DEF_WRITEMP4);
+ cfg->EncCfg.mpegVersion=reg.GetSetDword(REG_MPEGVER,DEF_MPEGVER);
+ cfg->EncCfg.aacObjectType=reg.GetSetDword(REG_PROFILE,DEF_PROFILE);
+ cfg->EncCfg.allowMidside=reg.GetSetDword(REG_MIDSIDE,DEF_MIDSIDE);
+ cfg->EncCfg.useTns=reg.GetSetDword(REG_TNS,DEF_TNS);
+ cfg->EncCfg.useLfe=reg.GetSetDword(REG_LFE,DEF_LFE);
+ cfg->UseQuality=reg.GetSetBool(REG_USEQUALTY,DEF_USEQUALTY);
+ cfg->EncCfg.quantqual=reg.GetSetDword(REG_QUALITY,DEF_QUALITY);
+ cfg->EncCfg.bitRate=reg.GetSetDword(REG_BITRATE,DEF_BITRATE);
+ cfg->EncCfg.bandWidth=reg.GetSetDword(REG_BANDWIDTH,DEF_BANDWIDTH);
+ cfg->EncCfg.outputFormat=reg.GetSetDword(REG_HEADER,DEF_HEADER);
+
+ FREE_ARRAY(cfg->OutDir);
+ cfg->OutDir=reg.GetSetStr(REG_OutFolder,"");
+
+ cfg->TagOn=reg.GetSetByte(REG_TAGON,0);
+#ifdef USE_IMPORT_TAG
+ cfg->TagImport=reg.GetSetByte(REG_TAGIMPORT,0);
+ #ifdef USE_PATHEXT
+ FREE_ARRAY(cfg->TagSrcPath);
+ FREE_ARRAY(cfg->TagSrcExt);
+ cfg->TagSrcPath=reg.GetSetStr(REG_InFolder,"");
+ cfg->TagSrcExt=reg.GetSetStr(REG_SrcExt,"");
+ #endif
+#endif
+ cfg->Tag.artist=reg.GetSetStr(REG_ARTIST,"");
+ cfg->Tag.title=reg.GetSetStr(REG_TITLE,"");
+ cfg->Tag.album=reg.GetSetStr(REG_ALBUM,"");
+ cfg->Tag.year=reg.GetSetStr(REG_YEAR,"");
+ cfg->Tag.genre=reg.GetSetStr(REG_GENRE,"");
+ cfg->Tag.writer=reg.GetSetStr(REG_WRITER,"");
+ cfg->Tag.comment=reg.GetSetStr(REG_COMMENT,"");
+ cfg->Tag.trackno=reg.GetSetWord(REG_TRACK,0);
+ cfg->Tag.ntracks=reg.GetSetWord(REG_NTRACKS,0);
+ cfg->Tag.discno=reg.GetSetWord(REG_DISK,0);
+ cfg->Tag.ndiscs=reg.GetSetWord(REG_NDISKS,0);
+ cfg->Tag.compilation=reg.GetSetByte(REG_COMPILATION,0);
+ cfg->Tag.artFilename=reg.GetSetStr(REG_ARTFILE,"");
+ }
+ else
+ MessageBox(0,"Can't open registry!",0,MB_OK|MB_ICONSTOP);
+}
+// -----------------------------------------------------------------------------------------------
+
+void CMyEncCfg::setCfg(CMyEncCfg *cfg)
+{
+CRegistry reg;
+
+ if(reg.OpenCreate(HKEY_CURRENT_USER, REGISTRY_PROGRAM_NAME "\\FAAC"))
+ {
+ reg.SetBool(REG_AUTO,cfg->AutoCfg);
+ reg.SetByte(REG_WRITEMP4,cfg->SaveMP4);
+ reg.SetDword(REG_MPEGVER,cfg->EncCfg.mpegVersion);
+ reg.SetDword(REG_PROFILE,cfg->EncCfg.aacObjectType);
+ reg.SetDword(REG_MIDSIDE,cfg->EncCfg.allowMidside);
+ reg.SetDword(REG_TNS,cfg->EncCfg.useTns);
+ reg.SetDword(REG_LFE,cfg->EncCfg.useLfe);
+ reg.SetBool(REG_USEQUALTY,cfg->UseQuality);
+ reg.SetDword(REG_QUALITY,cfg->EncCfg.quantqual);
+ reg.SetDword(REG_BITRATE,cfg->EncCfg.bitRate);
+ reg.SetDword(REG_BANDWIDTH,cfg->EncCfg.bandWidth);
+ reg.SetDword(REG_HEADER,cfg->EncCfg.outputFormat);
+
+ reg.SetStr(REG_OutFolder,cfg->OutDir);
+
+ reg.SetByte(REG_TAGON,cfg->TagOn);
+#ifdef USE_IMPORT_TAG
+ reg.SetByte(REG_TAGIMPORT,cfg->TagImport);
+ #ifdef USE_PATHEXT
+ reg.SetStr(REG_InFolder,cfg->TagSrcPath);
+ reg.SetStr(REG_SrcExt,cfg->TagSrcExt);
+ #endif
+#endif
+ reg.SetStr(REG_ARTIST,cfg->Tag.artist);
+ reg.SetStr(REG_TITLE,cfg->Tag.title);
+ reg.SetStr(REG_ALBUM,cfg->Tag.album);
+ reg.SetStr(REG_YEAR,cfg->Tag.year);
+ reg.SetStr(REG_GENRE,cfg->Tag.genre);
+ reg.SetStr(REG_WRITER,cfg->Tag.writer);
+ reg.SetStr(REG_COMMENT,cfg->Tag.comment);
+ reg.SetWord(REG_TRACK,cfg->Tag.trackno);
+ reg.SetWord(REG_NTRACKS,cfg->Tag.ntracks);
+ reg.SetWord(REG_DISK,cfg->Tag.discno);
+ reg.SetWord(REG_NDISKS,cfg->Tag.ndiscs);
+ reg.SetByte(REG_COMPILATION,cfg->Tag.compilation);
+ reg.SetStr(REG_ARTFILE,cfg->Tag.artFilename);
+ }
+ else
+ MessageBox(0,"Can't open registry!",0,MB_OK|MB_ICONSTOP);
+}
+
+// *********************************************************************************************
+// Cfaac
+// *********************************************************************************************
+
+
+
+Cfaac::Cfaac(HANDLE hOut)
+{
+ if(hOut)
+ {
+ hOutput=hOut;
+ return;
+ }
+
+ if(!(hOutput=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT,sizeof(MYOUTPUT))))
+ {
+ MessageBox(0, "Memory allocation error: hOutput", APP_NAME " plugin", MB_OK|MB_ICONSTOP); \
+ return;
+ }
+// dontAskGetFilename=false;
+}
+// -----------------------------------------------------------------------------------------------
+
+Cfaac::~Cfaac()
+{
+ if(!hOutput)
+ return;
+
+MYOUTPUT *mo;
+
+ GLOBALLOCK(mo,hOutput,MYOUTPUT,return);
+
+ if(mo->WrittenSamples)
+ {
+ int BytesWritten;
+ if(mo->bytes_into_buffer>0)
+ memset(mo->bufIn+mo->bytes_into_buffer, 0, (mo->samplesInput*(mo->BitsPerSample>>3))-mo->bytes_into_buffer);
+ do
+ {
+ if((BytesWritten=processData(hOutput,mo->bufIn,mo->bytes_into_buffer))<0)
+ MessageBox(0, "~Cfaac: processData", APP_NAME " plugin", MB_OK|MB_ICONSTOP);
+ mo->bytes_into_buffer=0;
+ }while(BytesWritten>0);
+ }
+
+ if(mo->aacFile)
+ {
+ fclose(mo->aacFile);
+ mo->aacFile=0;
+
+ CMyEncCfg cfg(false);
+ if(cfg.TagOn && mo->OutFilename)
+ {
+ int error=0;
+#ifdef USE_IMPORT_TAG
+ if(cfg.TagImport && mo->InFilename)
+ {
+ int l=strlen(mo->InFilename);
+ if( !strcmpi(mo->InFilename+l-4,".mp4") ||
+ !strcmpi(mo->InFilename+l-4,".m4a") ||
+ !strcmpi(mo->InFilename+l-4,".m4b"))
+ error=cfg.Tag.ReadMp4Tag(mo->InFilename);
+ else
+ error=cfg.Tag.ReadAacTag(mo->InFilename);
+ }
+#endif
+ if(!error)
+ cfg.Tag.WriteAacTag(mo->OutFilename);
+ }
+ }
+ else
+ {
+ MP4Close(mo->MP4File);
+ mo->MP4File=0;
+ }
+
+ if(mo->hEncoder)
+ faacEncClose(mo->hEncoder);
+
+ FREE_ARRAY(mo->bitbuf)
+ FREE_ARRAY(mo->buf32bit)
+ FREE_ARRAY(mo->bufIn)
+
+ FREE_ARRAY(mo->OutFilename)
+ FREE_ARRAY(mo->InFilename)
+
+ GlobalUnlock(hOutput);
+ GlobalFree(hOutput);
+}
+
+// *********************************************************************************************
+// Utilities
+// *********************************************************************************************
+
+char *Cfaac::getSourceFilename(char *path, char *src, char *ext)
+{
+char *dst, chExt,
+ *pname, *pext;
+
+
+ if(!src)
+ return NULL;
+ if(!path)
+ path="";
+ if(!ext)
+ ext="";
+ pname=pext=src+strlen(src);
+
+ while(pname!=src && *pname!='\\' && *pname!='/')
+ pname--;
+ if(*pname=='\\' || *pname=='/')
+ pname++;
+ while(pext!=src && *pext!='.')
+ pext--;
+ chExt=*pext;
+ if(chExt=='.')
+ *pext='\0';
+
+ if(*path)
+ {
+ int l;
+ if(!(dst=(char *)malloc(strlen(path)+strlen(pname)+strlen(ext)+3))) // '\0','\\','.'
+ return dst;
+ l=strlen(path);
+ if(l>0 && path[l-1]=='\\')
+ sprintf(dst,"%s%s.%s",path,pname,ext);
+ else
+ sprintf(dst,"%s\\%s.%s",path,pname,ext);
+ }
+ else
+ {
+ if(!(dst=(char *)malloc(strlen(pname)+strlen(ext)+2)))
+ return dst;
+ sprintf(dst,"%s.%s",pname,ext);
+ }
+ *pext=chExt;
+
+ if(!strcmpi(src,dst))
+ {
+// if(!dontAskGetFilename)
+ {
+ char buf[MAX_PATH+100];
+ sprintf(buf,"%s\nSource file=Destination file...aborting!\n\n\tSuppress this warning?",dst);
+// if(MessageBox(NULL,buf,NULL,MB_YESNO)==IDYES)
+// dontAskGetFilename=true;
+ }
+ FREE_ARRAY(dst);
+ return NULL;
+ }
+
+ return dst;
+}
+// *********************************************************************************************
+
+#define SWAP32(x) (((x & 0xff) << 24) | ((x & 0xff00) << 8) \
+ | ((x & 0xff0000) >> 8) | ((x & 0xff000000) >> 24))
+#define SWAP16(x) (((x & 0xff) << 8) | ((x & 0xff00) >> 8))
+
+void Cfaac::To32bit(int32_t *buf, BYTE *bufi, int size, BYTE samplebytes, BYTE bigendian)
+{
+int i;
+
+ switch(samplebytes)
+ {
+ case 1:
+ // this is endian clean
+ for (i = 0; i < size; i++)
+ buf[i] = (bufi[i] - 128) * 65536;
+ break;
+
+ case 2:
+#ifdef WORDS_BIGENDIAN
+ if (!bigendian)
+#else
+ if (bigendian)
+#endif
+ {
+ // swap bytes
+ for (i = 0; i < size; i++)
+ {
+ int16_t s = ((int16_t *)bufi)[i];
+
+ s = SWAP16(s);
+
+ buf[i] = ((u_int32_t)s) << 8;
+ }
+ }
+ else
+ {
+ // no swap
+ for (i = 0; i < size; i++)
+ {
+ int s = ((int16_t *)bufi)[i];
+
+ buf[i] = s << 8;
+ }
+ }
+ break;
+
+ case 3:
+ if (!bigendian)
+ {
+ for (i = 0; i < size; i++)
+ {
+ int s = bufi[3 * i] | (bufi[3 * i + 1] << 8) | (bufi[3 * i + 2] << 16);
+
+ // fix sign
+ if (s & 0x800000)
+ s |= 0xff000000;
+
+ buf[i] = s;
+ }
+ }
+ else // big endian input
+ {
+ for (i = 0; i < size; i++)
+ {
+ int s = (bufi[3 * i] << 16) | (bufi[3 * i + 1] << 8) | bufi[3 * i + 2];
+
+ // fix sign
+ if (s & 0x800000)
+ s |= 0xff000000;
+
+ buf[i] = s;
+ }
+ }
+ break;
+
+ case 4:
+#ifdef WORDS_BIGENDIAN
+ if (!bigendian)
+#else
+ if (bigendian)
+#endif
+ {
+ // swap bytes
+ for (i = 0; i < size; i++)
+ {
+ int s = bufi[i];
+
+ buf[i] = SWAP32(s);
+ }
+ }
+ else
+ memcpy(buf,bufi,size*sizeof(u_int32_t));
+ /*
+ int exponent, mantissa;
+ float *bufo=(float *)buf;
+
+ for (i = 0; i < size; i++)
+ {
+ exponent=bufi[(i<<2)+3]<<1;
+ if(bufi[i*4+2] & 0x80)
+ exponent|=0x01;
+ exponent-=126;
+ mantissa=(DWORD)bufi[(i<<2)+2]<<16;
+ mantissa|=(DWORD)bufi[(i<<2)+1]<<8;
+ mantissa|=bufi[(i<<2)];
+ bufo[i]=(float)ldexp(mantissa,exponent);
+ }*/
+ break;
+ }
+}
+
+// *********************************************************************************************
+// Main functions
+// *********************************************************************************************
+
+void Cfaac::DisplayError(char *ProcName, char *str)
+{
+char buf[100]="";
+
+ if(str && *str)
+ {
+ if(ProcName && *ProcName)
+ sprintf(buf,"%s: ", ProcName);
+ strcat(buf,str);
+ MessageBox(0, buf, APP_NAME " plugin", MB_OK|MB_ICONSTOP);
+ }
+
+MYOUTPUT *mo;
+ GLOBALLOCK(mo,hOutput,MYOUTPUT,return);
+ mo->bytes_into_buffer=-1;
+ GlobalUnlock(hOutput);
+ GlobalUnlock(hOutput);
+}
+// *********************************************************************************************
+
+HANDLE Cfaac::Init(LPSTR InFileName, LPSTR OutFileName,long lSamprate,WORD wBitsPerSample,WORD wChannels,long FileSize)
+{
+MYOUTPUT *mo;
+CMyEncCfg cfg(false);
+DWORD samplesInput,
+ maxBytesOutput;
+
+// if(wBitsPerSample!=8 && wBitsPerSample!=16) // 32 bit audio from cooledit is in unsupported format
+// return 0;
+ if(wChannels>48) // FAAC supports max 48 tracks!
+ return NULL;
+
+ GLOBALLOCK(mo,hOutput,MYOUTPUT,return NULL);
+
+ // open the encoder library
+ if(!(mo->hEncoder=faacEncOpen(lSamprate, wChannels, &samplesInput, &maxBytesOutput)))
+ return ERROR_Init("Can't open library");
+
+ if(!(mo->bitbuf=(unsigned char *)malloc(maxBytesOutput*sizeof(unsigned char))))
+ return ERROR_Init("Memory allocation error: output buffer");
+
+ if(!(mo->bufIn=(BYTE *)malloc(samplesInput*sizeof(int32_t))))
+ return ERROR_Init("Memory allocation error: input buffer");
+
+ if(!(mo->buf32bit=(int32_t *)malloc(samplesInput*sizeof(int32_t))))
+ return ERROR_Init("Memory allocation error: 32 bit buffer");
+
+ if(cfg.SaveMP4)// || cfg.Tag.On)
+ {
+ int ExtPos=0, // append new ext
+ fnLen=lstrlen(OutFileName);
+// if(OutFileName[lstrlen(OutFileName)-4]=='.')
+ if( fnLen>=4 &&
+ (!strcmpi(OutFileName+fnLen-4,".aac") ||
+ !strcmpi(OutFileName+fnLen-4,".mp4") ||
+ !strcmpi(OutFileName+fnLen-4,".m4a") ||
+ !strcmpi(OutFileName+fnLen-4,".m4b"))) // no aac/mp4 ext => append new ext
+ if( (cfg.SaveMP4==1 && strcmpi(OutFileName+fnLen-4,".mp4")) ||
+ (cfg.SaveMP4==2 && strcmpi(OutFileName+fnLen-4,".m4a")) ||
+ (cfg.SaveMP4==3 && strcmpi(OutFileName+fnLen-4,".m4b")))
+ ExtPos=4; // wrong ext => replace it
+ else
+ ExtPos=-1; // correct ext => no action
+ if(ExtPos!=-1)
+ {
+ switch(cfg.SaveMP4)
+ {
+ case 1: strcpy(OutFileName+fnLen-ExtPos,".mp4"); break;
+ case 2: strcpy(OutFileName+fnLen-ExtPos,".m4a"); break;
+ case 3: strcpy(OutFileName+fnLen-ExtPos,".m4b"); break;
+ }
+ FILE *f=fopen(OutFileName,"rb");
+ if(f)
+ {
+ char buf[MAX_PATH+20];
+ sprintf(buf,"Overwrite \"%s\" ?",OutFileName);
+ fclose(f);
+ if(MessageBox(NULL,buf,"File already exists!",MB_YESNO|MB_ICONQUESTION)==IDNO)
+ return ERROR_Init(0);//"User abort");
+ }
+ }
+ }
+ mo->WriteMP4= !strcmpi(OutFileName+lstrlen(OutFileName)-4,".mp4") ||
+ !strcmpi(OutFileName+lstrlen(OutFileName)-4,".m4a") ||
+ !strcmpi(OutFileName+lstrlen(OutFileName)-4,".m4b");
+
+faacEncConfigurationPtr CurFormat=faacEncGetCurrentConfiguration(mo->hEncoder);
+ CurFormat->inputFormat=FAAC_INPUT_32BIT;
+/* switch(wBitsPerSample)
+ {
+ case 16:
+ CurFormat->inputFormat=FAAC_INPUT_16BIT;
+ break;
+ case 24:
+ CurFormat->inputFormat=FAAC_INPUT_24BIT;
+ break;
+ case 32:
+ CurFormat->inputFormat=FAAC_INPUT_32BIT;
+ break;
+ default:
+ CurFormat->inputFormat=FAAC_INPUT_NULL;
+ break;
+ }*/
+ if(!cfg.AutoCfg)
+ {
+ faacEncConfigurationPtr myFormat=&cfg.EncCfg;
+
+ if(cfg.UseQuality)
+ {
+ CurFormat->quantqual=myFormat->quantqual;
+ CurFormat->bitRate=0;//myFormat->bitRate;
+ }
+ else
+ {
+ CurFormat->bitRate=(myFormat->bitRate*1000)/wChannels;
+ CurFormat->quantqual=100;
+ }
+
+ switch(CurFormat->bandWidth)
+ {
+ case 0: // Auto
+ break;
+ case 0xffffffff: // Full
+ CurFormat->bandWidth=lSamprate/2;
+ break;
+ default:
+ CurFormat->bandWidth=myFormat->bandWidth;
+ break;
+ }
+ CurFormat->mpegVersion=myFormat->mpegVersion;
+ CurFormat->outputFormat=myFormat->outputFormat;
+ CurFormat->mpegVersion=myFormat->mpegVersion;
+ CurFormat->aacObjectType=myFormat->aacObjectType;
+ CurFormat->allowMidside=myFormat->allowMidside;
+// CurFormat->useTns=myFormat->useTns;
+ CurFormat->useTns=false;
+ }
+ else
+ {
+ CurFormat->mpegVersion=DEF_MPEGVER;
+ CurFormat->aacObjectType=DEF_PROFILE;
+ CurFormat->allowMidside=DEF_MIDSIDE;
+// CurFormat->useTns=DEF_TNS;
+ CurFormat->useTns=false;
+ CurFormat->useLfe=DEF_LFE;
+ CurFormat->quantqual=DEF_QUALITY;
+ CurFormat->bitRate=DEF_BITRATE;
+ CurFormat->bandWidth=DEF_BANDWIDTH;
+ CurFormat->outputFormat=DEF_HEADER;
+ }
+ if(mo->WriteMP4)
+ CurFormat->outputFormat=RAW;
+ CurFormat->useLfe=wChannels>=6 ? 1 : 0;
+ if(!faacEncSetConfiguration(mo->hEncoder, CurFormat))
+ return ERROR_Init("Unsupported parameters!");
+
+// mo->src_size=lSize;
+// mi->dst_name=strdup(OutFileName);
+ mo->Samprate=lSamprate;
+ mo->BitsPerSample=wBitsPerSample;
+ mo->Channels=wChannels;
+ mo->samplesInput=samplesInput;
+ mo->samplesInputSize=samplesInput*(mo->BitsPerSample>>3);
+
+ mo->maxBytesOutput=maxBytesOutput;
+
+ if(mo->WriteMP4) // Create MP4 file --------------------------------------------------------------------------
+ {
+ BYTE *ASC=0;
+ DWORD ASCLength=0;
+
+ if((mo->MP4File=MP4Create(OutFileName, 0, 0, 0))==MP4_INVALID_FILE_HANDLE)
+ return ERROR_Init("Can't create file");
+ MP4SetTimeScale(mo->MP4File, 90000);
+ mo->MP4track=MP4AddAudioTrack(mo->MP4File, lSamprate, MP4_INVALID_DURATION, MP4_MPEG4_AUDIO_TYPE);
+ MP4SetAudioProfileLevel(mo->MP4File, 0x0F);
+ faacEncGetDecoderSpecificInfo(mo->hEncoder, &ASC, &ASCLength);
+ MP4SetTrackESConfiguration(mo->MP4File, mo->MP4track, (unsigned __int8 *)ASC, ASCLength);
+ mo->frameSize=samplesInput/wChannels;
+ mo->ofs=mo->frameSize;
+
+ if(cfg.TagOn)
+ {
+ int error=0;
+#ifdef USE_IMPORT_TAG
+ if(cfg.TagImport && InFileName)
+ {
+ int l=strlen(InFileName);
+ if( !strcmpi(InFileName+l-4,".mp4") ||
+ !strcmpi(InFileName+l-4,".m4a") ||
+ !strcmpi(InFileName+l-4,".m4b"))
+ error=cfg.Tag.ReadMp4Tag(InFileName);
+ else
+ error=cfg.Tag.ReadAacTag(InFileName);
+ }
+#endif
+ if(!error)
+ cfg.Tag.WriteMP4Tag(mo->MP4File);
+ }
+ }
+ else // Create AAC file -----------------------------------------------------------------------------
+ {
+ // open the aac output file
+ if(!(mo->aacFile=fopen(OutFileName, "wb")))
+ return ERROR_Init("Can't create file");
+
+ // use bufferized stream
+ setvbuf(mo->aacFile,NULL,_IOFBF,32767);
+
+ mo->InFilename=strdup(InFileName);
+ mo->OutFilename=strdup(OutFileName);
+ }
+
+ showInfo(mo);
+
+ GlobalUnlock(hOutput);
+ return hOutput;
+}
+// *********************************************************************************************
+
+int Cfaac::processData(HANDLE hOutput, BYTE *bufIn, DWORD len)
+{
+ if(!hOutput)
+ return -1;
+
+int bytesWritten=0;
+int bytesEncoded;
+MYOUTPUT far *mo;
+
+ GLOBALLOCK(mo,hOutput,MYOUTPUT,return 0);
+
+int32_t *buf=mo->buf32bit;
+
+ if((int)len<mo->samplesInputSize)
+ {
+ mo->samplesInput=(len<<3)/mo->BitsPerSample;
+ mo->samplesInputSize=mo->samplesInput*(mo->BitsPerSample>>3);
+ }
+// if(mo->BitsPerSample==8 || mo->BitsPerSample==32)
+ To32bit(buf,bufIn,mo->samplesInput,mo->BitsPerSample>>3,false);
+
+ // call the actual encoding routine
+ if((bytesEncoded=faacEncEncode(mo->hEncoder, (int32_t *)buf, mo->samplesInput, mo->bitbuf, mo->maxBytesOutput))<0)
+ return ERROR_processData("faacEncEncode()");
+
+ // write bitstream to aac file
+ if(mo->aacFile)
+ {
+ if(bytesEncoded>0)
+ {
+ if((bytesWritten=fwrite(mo->bitbuf, 1, bytesEncoded, mo->aacFile))!=bytesEncoded)
+ return ERROR_processData("Write failed!");
+ mo->WrittenSamples=1; // needed into destructor
+ }
+ }
+ else
+ // write bitstream to mp4 file
+ {
+ MP4Duration dur,
+ SamplesLeft;
+ if(len>0)
+ {
+ mo->srcSize+=len;
+ dur=mo->frameSize;
+ }
+ else
+ {
+ mo->TotalSamples=(mo->srcSize<<3)/(mo->BitsPerSample*mo->Channels);
+ SamplesLeft=(mo->TotalSamples-mo->WrittenSamples)+mo->frameSize;
+ dur=SamplesLeft>mo->frameSize ? mo->frameSize : SamplesLeft;
+ }
+ if(bytesEncoded>0)
+ {
+ if(!(bytesWritten=MP4WriteSample(mo->MP4File, mo->MP4track, (unsigned __int8 *)mo->bitbuf, (DWORD)bytesEncoded, dur, mo->ofs, true) ? bytesEncoded : -1))
+ return ERROR_processData("MP4WriteSample()");
+ mo->ofs=0;
+ mo->WrittenSamples+=dur;
+ }
+ }
+
+ showProgress(mo);
+
+ GlobalUnlock(hOutput);
+ return bytesWritten;
+}
+// -----------------------------------------------------------------------------------------------
+
+int Cfaac::processDataBufferized(HANDLE hOutput, BYTE *bufIn, long lBytes)
+{
+ if(!hOutput)
+ return -1;
+
+int bytesWritten=0, tot=0;
+MYOUTPUT far *mo;
+
+ GLOBALLOCK(mo,hOutput,MYOUTPUT,return 0);
+
+ if(mo->bytes_into_buffer>=0)
+ do
+ {
+ if(mo->bytes_into_buffer+lBytes<mo->samplesInputSize)
+ {
+ memmove(mo->bufIn+mo->bytes_into_buffer, bufIn, lBytes);
+ mo->bytes_into_buffer+=lBytes;
+ lBytes=0;
+ }
+ else
+ {
+ int shift=mo->samplesInputSize-mo->bytes_into_buffer;
+ memmove(mo->bufIn+mo->bytes_into_buffer, bufIn, shift);
+ mo->bytes_into_buffer+=shift;
+ bufIn+=shift;
+ lBytes-=shift;
+
+ tot+=bytesWritten=processData(hOutput,mo->bufIn,mo->bytes_into_buffer);
+ if(bytesWritten<0)
+ return ERROR_processData(0);
+ mo->bytes_into_buffer=0;
+ }
+ }while(lBytes);
+
+ GlobalUnlock(hOutput);
+ return tot;
+}
--- /dev/null
+++ b/common/Cfaac/Cfaac.h
@@ -1,0 +1,184 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#ifndef _Cfaac_H
+#define _Cfaac_H
+
+// *********************************************************************************************
+
+#include <mp4.h> // int32_t, ...
+#include <faad.h> // FAAD2 version
+#ifdef MAIN
+ #undef MAIN
+#endif
+#ifdef SSR
+ #undef SSR
+#endif
+#ifdef LTP
+ #undef LTP
+#endif
+#include <faac.h>
+#include <win32_ver.h> // mpeg4ip version
+#include "CRegistry.h"
+#include "CTag.h"
+#include "Defines.h" // my defines
+
+// *********************************************************************************************
+
+#ifdef ADTS
+#undef ADTS
+#define ADTS 1
+#endif
+
+// *********************************************************************************************
+
+#define REG_AUTO "Auto"
+#define DEF_AUTO true
+#define REG_WRITEMP4 "Write MP4"
+#define DEF_WRITEMP4 0
+#define REG_MPEGVER "MPEG version"
+#define DEF_MPEGVER MPEG4
+#define REG_PROFILE "Profile"
+#define DEF_PROFILE LOW
+#define REG_MIDSIDE "MidSide"
+#define DEF_MIDSIDE true
+#define REG_TNS "TNS"
+#define DEF_TNS true
+#define REG_LFE "LFE"
+#define DEF_LFE false
+#define REG_USEQUALTY "Use quality"
+#define DEF_USEQUALTY true
+#define REG_QUALITY "Quality"
+#define DEF_QUALITY 100
+#define REG_BITRATE "BitRate"
+#define DEF_BITRATE 0 /* quality on */
+#define REG_BANDWIDTH "BandWidth"
+#define DEF_BANDWIDTH 0
+#define REG_HEADER "Header"
+#define DEF_HEADER ADTS
+
+#define REG_OutFolder "Output folder"
+#define REG_InFolder "Source folder"
+#define REG_SrcExt "Source extensions"
+
+// *********************************************************************************************
+
+class CMyEncCfg
+{
+private:
+
+ bool SaveCfgOnDestroy;
+
+public:
+
+ CMyEncCfg(bool SaveOnDestroy=true) { OutDir=TagSrcPath=TagSrcExt=NULL; getCfg(this); SaveCfgOnDestroy=SaveOnDestroy; }
+ virtual ~CMyEncCfg() { if(SaveCfgOnDestroy) setCfg(this); FreeCfg(this); }
+
+ void FreeCfg(CMyEncCfg *cfg) { Tag.FreeTag(); FREE_ARRAY(OutDir); FREE_ARRAY(TagSrcPath); FREE_ARRAY(TagSrcExt); }
+ void getCfg(CMyEncCfg *cfg);
+ void setCfg(CMyEncCfg *cfg);
+
+ bool AutoCfg,
+ UseQuality;
+ BYTE SaveMP4;
+ char *OutDir;
+ faacEncConfiguration EncCfg;
+ CMP4Tag Tag;
+ BYTE TagOn;
+ BYTE TagImport;
+ char *TagSrcPath,
+ *TagSrcExt;
+};
+// -----------------------------------------------------------------------------------------------
+
+typedef struct output_tag // any special vars associated with output file
+{
+// MP4
+MP4FileHandle MP4File;
+MP4TrackId MP4track;
+MP4Duration TotalSamples,
+ WrittenSamples,
+ encoded_samples;
+DWORD frameSize,
+ ofs;
+
+// AAC
+FILE *aacFile;
+char *InFilename,
+ *OutFilename;
+
+// GLOBAL
+long Samprate;
+WORD BitsPerSample;
+WORD Channels;
+DWORD srcSize;
+//char *dst_name; // name of compressed file
+
+faacEncHandle hEncoder;
+int32_t *buf32bit;
+BYTE *bufIn;
+unsigned char *bitbuf;
+long bytes_into_buffer;
+DWORD maxBytesOutput;
+long samplesInput,
+ samplesInputSize;
+bool WriteMP4;
+} MYOUTPUT;
+
+
+
+// *********************************************************************************************
+
+
+
+class Cfaac
+{
+private:
+ virtual void DisplayError(char *ProcName, char *str);
+ virtual HANDLE ERROR_Init(char *str) { DisplayError("Init", str); return NULL; }
+ virtual int ERROR_processData(char *str) { DisplayError("processData", str); return -1; }
+ virtual void showInfo(MYOUTPUT *mi) {}
+ virtual void showProgress(MYOUTPUT *mi) {}
+ void To32bit(int32_t *buf, BYTE *bufi, int size, BYTE samplebytes, BYTE bigendian);
+
+public:
+ Cfaac(HANDLE hOutput=NULL);
+ virtual ~Cfaac();
+
+ virtual char *getSourceFilename(char *path, char *src, char *ext);
+
+ virtual HANDLE Init(LPSTR InFilename,LPSTR OutFilename,long lSamprate,WORD wBitsPerSample,WORD wChannels,long FileSize);
+ virtual int processData(HANDLE hOutput, BYTE *bufIn, DWORD len);
+ virtual int processDataBufferized(HANDLE hOutput, BYTE *bufIn, long lBytes);
+/*
+// AAC
+ bool BlockSeeking;
+
+// GLOBAL
+ long newpos_ms;
+ BOOL IsSeekable;
+ MYINPUT *mi;
+*/
+ HANDLE hOutput;
+// bool dontAskGetFilename;
+};
+
+#endif
--- /dev/null
+++ b/common/Cfaac/Cfaad.cpp
@@ -1,0 +1,807 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include "Cfaad.h"
+
+
+
+// *********************************************************************************************
+
+
+
+Cfaad::Cfaad(HANDLE hIn)
+{
+ ShowDlg4RawAAC=NULL;
+ pCfg=NULL;
+
+ if(hIn)
+ {
+ hInput=hIn;
+ return;
+ }
+
+MYINPUT *mi;
+
+ if(!(hInput=GlobalAlloc(GMEM_MOVEABLE|GMEM_SHARE|GMEM_ZEROINIT,sizeof(MYINPUT))))
+ MessageBox(0, "Memory allocation error: hInput", APP_NAME " plugin", MB_OK|MB_ICONSTOP); \
+ if(!(mi=(MYINPUT *)GlobalLock(hInput)))
+ MessageBox(0, "GlobalLock(hInput)", APP_NAME " plugin", MB_OK|MB_ICONSTOP); \
+/*
+ mi->mp4File=0;
+ mi->aacFile=0;
+ mi->hDecoder=0;
+ mi->buffer=0;
+ mi->bytes_read=0;*/
+ mi->BitsPerSample=16;
+ mi->FindBitrate=FALSE;
+ newpos_ms=-1;
+ mi->seek_table=NULL;
+ mi->seek_table_length=0;
+ mi->LockSeeking=false;
+ GlobalUnlock(hInput);
+}
+// -----------------------------------------------------------------------------------------------
+
+Cfaad::~Cfaad()
+{
+MYINPUT *mi;
+
+ if(!hInput)
+ return;
+
+ GLOBALLOCK(mi,hInput,MYINPUT,return);
+
+ if(mi->mp4File)
+ MP4Close(mi->mp4File);
+ if(mi->aacFile)
+ fclose(mi->aacFile);
+ if(mi->hDecoder)
+ faacDecClose(mi->hDecoder);
+ FREE_ARRAY(mi->buffer);
+ FREE_ARRAY(mi->seek_table);
+
+ GlobalUnlock(hInput);
+ GlobalFree(hInput);
+}
+
+// *********************************************************************************************
+// Utilities
+// *********************************************************************************************
+
+int Cfaad::GetAACTrack(MP4FileHandle infile)
+{
+// find AAC track
+int i, rc;
+int numTracks = MP4GetNumberOfTracks(infile, NULL, 0);
+
+ for (i = 0; i < numTracks; i++)
+ {
+ MP4TrackId trackId = MP4FindTrackId(infile, i, NULL, 0);
+ const char* trackType = MP4GetTrackType(infile, trackId);
+
+ if (!strcmp(trackType, MP4_AUDIO_TRACK_TYPE))
+ {
+ unsigned char *buff = NULL;
+ unsigned __int32 buff_size = 0;
+ mp4AudioSpecificConfig mp4ASC;
+
+ MP4GetTrackESConfiguration(infile, trackId, (unsigned __int8 **)&buff, &buff_size);
+
+ if (buff)
+ {
+ rc = AudioSpecificConfig(buff, buff_size, &mp4ASC);
+ free(buff);
+
+ if (rc < 0)
+ return -1;
+ return trackId;
+ }
+ }
+ }
+
+ // can't decode this
+ return -1;
+}
+// *********************************************************************************************
+
+int Cfaad::IsMP4(LPSTR lpstrFilename)
+{
+DWORD mp4file = 0;
+FILE *hMP4File = fopen(lpstrFilename, "rb");
+BYTE header[8];
+ if(!hMP4File)
+ return -1;
+ fread(header, 1, 8, hMP4File);
+ fclose(hMP4File);
+ if(header[4]=='f' && header[5]=='t' && header[6]=='y' && header[7]=='p')
+ return 1;
+
+ return 0;
+}
+// *********************************************************************************************
+long Cfaad::id3v2_TagSize(unsigned char *buffer)
+{
+ if(StringComp((const char *)buffer, "ID3", 3) == 0)
+ {
+ unsigned long tagsize;
+
+ // high bit is not used
+ tagsize = (buffer[6] << 21) | (buffer[7] << 14) |
+ (buffer[8] << 7) | (buffer[9] << 0);
+ tagsize += 10;
+ return tagsize;
+ }
+ return 0;
+}
+/*
+long Cfaad::id3v2_TagSize(aac_buffer *b)
+{
+DWORD tagsize = 0;
+ if (!memcmp(b->buffer, "ID3", 3))
+ {
+ // high bit is not used
+ tagsize = (b->buffer[6] << 21) | (b->buffer[7] << 14) |
+ (b->buffer[8] << 7) | (b->buffer[9] << 0);
+
+ tagsize += 10;
+ advance_buffer(b, tagsize);
+ fill_buffer(b);
+ }
+ return tagsize;
+}
+// *********************************************************************************************
+
+int Cfaad::fill_buffer(aac_buffer *b)
+{
+ int bread;
+
+ if (b->bytes_consumed > 0)
+ {
+ if (b->bytes_into_buffer)
+ {
+ memmove((void*)b->buffer, (void*)(b->buffer + b->bytes_consumed),
+ b->bytes_into_buffer*sizeof(unsigned char));
+ }
+
+ if (!b->at_eof)
+ {
+ bread = fread((void*)(b->buffer + b->bytes_into_buffer), 1,
+ b->bytes_consumed, b->infile);
+
+ if (bread != b->bytes_consumed)
+ b->at_eof = 1;
+
+ b->bytes_into_buffer += bread;
+ }
+
+ b->bytes_consumed = 0;
+
+ if (b->bytes_into_buffer > 3)
+ {
+ if (memcmp(b->buffer, "TAG", 3) == 0)
+ b->bytes_into_buffer = 0;
+ }
+ if (b->bytes_into_buffer > 11)
+ {
+ if (memcmp(b->buffer, "LYRICSBEGIN", 11) == 0)
+ b->bytes_into_buffer = 0;
+ }
+ if (b->bytes_into_buffer > 8)
+ {
+ if (memcmp(b->buffer, "APETAGEX", 8) == 0)
+ b->bytes_into_buffer = 0;
+ }
+ }
+
+ return 1;
+}
+// *********************************************************************************************
+
+void Cfaad::advance_buffer(aac_buffer *b, int bytes)
+{
+ b->file_offset += bytes;
+ b->bytes_consumed = bytes;
+ b->bytes_into_buffer -= bytes;
+}
+// *********************************************************************************************
+
+static int adts_sample_rates[] = {96000,88200,64000,48000,44100,32000,24000,22050,16000,12000,11025,8000,7350,0,0,0};
+
+int Cfaad::adts_parse(aac_buffer *b, int *bitrate, float *length)
+{
+ int frames, frame_length;
+ int t_framelength = 0;
+ int samplerate;
+ float frames_per_sec, bytes_per_frame;
+
+ // Read all frames to ensure correct time and bitrate
+ for (frames = 0; ; frames++)
+ {
+ fill_buffer(b);
+
+ if (b->bytes_into_buffer > 7)
+ {
+ // check syncword
+ if (!((b->buffer[0] == 0xFF)&&((b->buffer[1] & 0xF6) == 0xF0)))
+ break;
+
+ if (frames == 0)
+ samplerate = adts_sample_rates[(b->buffer[2]&0x3c)>>2];
+
+ frame_length = ((((unsigned int)b->buffer[3] & 0x3)) << 11)
+ | (((unsigned int)b->buffer[4]) << 3) | (b->buffer[5] >> 5);
+
+ t_framelength += frame_length;
+
+ if (frame_length > b->bytes_into_buffer)
+ break;
+
+ advance_buffer(b, frame_length);
+ } else {
+ break;
+ }
+ }
+
+ frames_per_sec = (float)samplerate/1024.0f;
+ if (frames != 0)
+ bytes_per_frame = (float)t_framelength/(float)(frames*1000);
+ else
+ bytes_per_frame = 0;
+ *bitrate = (int)(8. * bytes_per_frame * frames_per_sec + 0.5);
+ if (frames_per_sec != 0)
+ *length = (float)frames/frames_per_sec;
+ else
+ *length = 1;
+
+ return 1;
+}
+// *********************************************************************************************
+
+// get AAC infos for printing
+void Cfaad::GetAACInfos(aac_buffer *b, DWORD *header_type, float *song_length, int *pbitrate, long filesize)
+{
+int bitrate=0;
+float length=0;
+int bread;
+long tagsize=id3v2_TagSize(b);
+
+ *header_type = 0;
+ b->file_offset=tagsize;
+
+ if ((b->buffer[0] == 0xFF) && ((b->buffer[1] & 0xF6) == 0xF0))
+ {
+ adts_parse(b, &bitrate, &length);
+ fseek(b->infile, tagsize, SEEK_SET);
+
+ bread = fread(b->buffer, 1, FAAD_MIN_STREAMSIZE*MAX_CHANNELS, b->infile);
+ if (bread != FAAD_MIN_STREAMSIZE*MAX_CHANNELS)
+ b->at_eof = 1;
+ else
+ b->at_eof = 0;
+ b->bytes_into_buffer = bread;
+ b->bytes_consumed = 0;
+ b->file_offset = tagsize;
+
+ *header_type = 1;
+ } else if (memcmp(b->buffer, "ADIF", 4) == 0) {
+ int skip_size = (b->buffer[4] & 0x80) ? 9 : 0;
+ bitrate = ((unsigned int)(b->buffer[4 + skip_size] & 0x0F)<<19) |
+ ((unsigned int)b->buffer[5 + skip_size]<<11) |
+ ((unsigned int)b->buffer[6 + skip_size]<<3) |
+ ((unsigned int)b->buffer[7 + skip_size] & 0xE0);
+
+ length = (float)filesize;
+ if (length != 0)
+ {
+ length = ((float)length*8.f)/((float)bitrate) + 0.5f;
+ }
+
+ bitrate = (int)((float)bitrate/1000.0f + 0.5f);
+
+ *header_type = 2;
+ }
+
+ *song_length = length;
+ *pbitrate=bitrate;
+}
+
+void Cfaad::GetAACInfos(char *Filename, aac_buffer *b, DWORD *header_type, float *song_length, int *pbitrate)
+{
+ if(!(b->infile=fopen(Filename,"rb")))
+ {
+ MessageBox(NULL,"Error opening file",NULL,MB_OK);
+ return;
+ }
+ fseek(b->infile, 0, SEEK_END);
+long src_size=ftell(b->infile);
+ fseek(b->infile, 0, SEEK_SET);
+ if(!(b->buffer=(BYTE *)malloc(FAAD_STREAMSIZE)))
+ {
+ MessageBox(NULL,"Memory allocation error: b->buffer",NULL,MB_OK);
+ return;
+ }
+
+int tread=src_size<FAAD_STREAMSIZE ? src_size : FAAD_STREAMSIZE;
+ b->bytes_into_buffer=fread(b->buffer, 1, tread, b->infile);
+ if(b->bytes_into_buffer!=tread)
+ {
+ MessageBox(NULL,"Read failed!",NULL,MB_OK);
+ return;
+ }
+ b->bytes_consumed=0;
+ b->file_offset=0;
+ b->at_eof=(b->bytes_into_buffer!=tread) ? 1 : 0;
+
+ *header_type = 0;
+ b->file_offset=0;
+
+ GetAACInfos(b,header_type,song_length,pbitrate,src_size);
+
+ free(b->buffer);
+ fclose(b->infile);
+}
+*/
+// *********************************************************************************************
+// Main functions
+// *********************************************************************************************
+
+void CMyDecCfg::getCfg(CMyDecCfg *cfg)
+{
+CRegistry reg;
+
+if(reg.OpenCreate(HKEY_CURRENT_USER, REGISTRY_PROGRAM_NAME "\\FAAD"))
+ {
+ cfg->DefaultCfg=reg.GetSetBool(REG_DEFAULT,true);
+ cfg->DecCfg.defObjectType=reg.GetSetByte(REG_PROFILE,LC);
+ cfg->DecCfg.defSampleRate=reg.GetSetDword(REG_SAMPLERATE,44100);
+ cfg->DecCfg.outputFormat=reg.GetSetByte(REG_BPS,FAAD_FMT_16BIT);
+ cfg->DecCfg.downMatrix=reg.GetSetByte(REG_DOWNMATRIX,0);
+ cfg->DecCfg.useOldADTSFormat=reg.GetSetByte(REG_OLDADTS,0);
+ cfg->DecCfg.dontUpSampleImplicitSBR=reg.GetSetByte(REG_DONTUPSAMPLESBR,1);
+// cfg->Channels=reg.GetSetByte("Channels",2);
+ }
+ else
+ MessageBox(0,"Can't open registry!",0,MB_OK|MB_ICONSTOP);
+}
+// -----------------------------------------------------------------------------------------------
+
+void CMyDecCfg::setCfg(CMyDecCfg *cfg)
+{
+CRegistry reg;
+
+ if(reg.OpenCreate(HKEY_CURRENT_USER, REGISTRY_PROGRAM_NAME "\\FAAD"))
+ {
+ reg.SetBool(REG_DEFAULT,cfg->DefaultCfg);
+ reg.SetByte(REG_PROFILE,cfg->DecCfg.defObjectType);
+ reg.SetDword(REG_SAMPLERATE,cfg->DecCfg.defSampleRate);
+ reg.SetByte(REG_BPS,cfg->DecCfg.outputFormat);
+ reg.SetByte(REG_DOWNMATRIX,cfg->DecCfg.downMatrix);
+ reg.SetByte(REG_OLDADTS,cfg->DecCfg.useOldADTSFormat);
+ reg.SetByte(REG_DONTUPSAMPLESBR,cfg->DecCfg.dontUpSampleImplicitSBR);
+// reg.SetByte("Channels",cfg->Channels);
+ }
+ else
+ MessageBox(0,"Can't open registry!",0,MB_OK|MB_ICONSTOP);
+}
+// *********************************************************************************************
+
+void Cfaad::setFaadCfg(faacDecHandle hDecoder, CMyDecCfg Cfg)
+{
+faacDecConfigurationPtr config=faacDecGetCurrentConfiguration(hDecoder);
+
+ if(!Cfg.DefaultCfg)
+ {
+ config->defObjectType=Cfg.DecCfg.defObjectType;
+ config->outputFormat=Cfg.DecCfg.outputFormat;
+ config->defSampleRate=Cfg.DecCfg.defSampleRate;
+ config->downMatrix=Cfg.DecCfg.downMatrix;
+ config->useOldADTSFormat=Cfg.DecCfg.useOldADTSFormat;
+ config->dontUpSampleImplicitSBR=1;
+ }
+ else
+ {
+ config->defObjectType=LC;
+ config->outputFormat=FAAD_FMT_16BIT;
+ config->defSampleRate=44100;
+ config->downMatrix=0;
+ config->useOldADTSFormat=0;
+ config->dontUpSampleImplicitSBR=1;
+ }
+ faacDecSetConfiguration(hDecoder, config);
+}
+// -----------------------------------------------------------------------------------------------
+
+void Cfaad::setDefaultFaadCfg(faacDecHandle hDecoder, BOOL showDlg)
+{
+ if(showDlg && ShowDlg4RawAAC)
+ ShowDlg4RawAAC();
+
+CMyDecCfg Cfg(false);
+ setFaadCfg(hDecoder,Cfg);
+}
+// -----------------------------------------------------------------------------------------------
+
+void Cfaad::DisplayError(char *ProcName, char *str)
+{
+MYINPUT *mi;
+char buf[100]="";
+
+ GlobalUnlock(hInput); // it wasn't done in getInfos()
+ GLOBALLOCK(mi,hInput,MYINPUT,return);
+
+ if(ProcName && *ProcName)
+ sprintf(buf,"%s: ", ProcName);
+ if(str && *str)
+ strcat(buf,str);
+ if(*buf && str)
+ MessageBox(0, buf, APP_NAME " plugin", MB_OK|MB_ICONSTOP);
+
+ mi->bytes_into_buffer=-1;
+ GlobalUnlock(hInput);
+}
+// *********************************************************************************************
+
+HANDLE Cfaad::getInfos(LPSTR lpstrFilename)
+{
+MYINPUT *mi;
+
+// test tags
+//CMyDecCfg cfg; cfg.Tag.ReadMp4Tag(lpstrFilename);
+//CMyDecCfg cfg; cfg.Tag.ReadAacTag(lpstrFilename);
+
+ GLOBALLOCK(mi,hInput,MYINPUT,return NULL);
+
+// mi->IsAAC=strcmpi(lpstrFilename+lstrlen(lpstrFilename)-4,".aac")==0;
+ if((mi->IsMP4=IsMP4(lpstrFilename))==-1)
+ return ERROR_getInfos("Error opening file");
+
+ if(mi->IsMP4) // MP4 file ---------------------------------------------------------------------
+ {
+ MP4Duration length;
+ unsigned __int32 buffer_size;
+ DWORD timeScale;
+ BYTE sf;
+ mp4AudioSpecificConfig mp4ASC;
+
+ if(!(mi->mp4File=MP4Read(lpstrFilename, 0)))
+ return ERROR_getInfos("Error opening file");
+
+ if((mi->track=GetAACTrack(mi->mp4File))<0)
+ return ERROR_getInfos(0); //"Unable to find correct AAC sound track");
+
+ if(!(mi->hDecoder=faacDecOpen()))
+ return ERROR_getInfos("Error initializing decoder library");
+
+ MP4GetTrackESConfiguration(mi->mp4File, mi->track, (unsigned __int8 **)&mi->buffer, &buffer_size);
+ if(!mi->buffer)
+ return ERROR_getInfos("MP4GetTrackESConfiguration()");
+ AudioSpecificConfig(mi->buffer, buffer_size, &mp4ASC);
+
+ timeScale = mp4ASC.samplingFrequency;
+ mi->Channels=mp4ASC.channelsConfiguration;
+ sf = mp4ASC.samplingFrequencyIndex;
+ mi->type = mp4ASC.objectTypeIndex;
+// mi->SBR=mp4ASC.sbr_present_flag;
+
+ if(faacDecInit2(mi->hDecoder, mi->buffer, buffer_size, &mi->Samprate, &mi->Channels) < 0)
+ return ERROR_getInfos("Error initializing decoder library");
+ FREE_ARRAY(mi->buffer);
+
+ length=MP4GetTrackDuration(mi->mp4File, mi->track);
+ mi->len_ms=(DWORD)MP4ConvertFromTrackDuration(mi->mp4File, mi->track, length, MP4_MSECS_TIME_SCALE);
+ mi->file_info.bitrate=MP4GetTrackBitRate(mi->mp4File, mi->track);
+ mi->file_info.version=MP4GetTrackAudioType(mi->mp4File, mi->track)==MP4_MPEG4_AUDIO_TYPE ? 4 : 2;
+ mi->numSamples=MP4GetTrackNumberOfSamples(mi->mp4File, mi->track);
+ mi->sampleId=1;
+
+ mi->IsSeekable=true;
+ mi->LockSeeking=!mi->IsSeekable;
+ }
+ else // AAC file ------------------------------------------------------------------------------
+ {
+ DWORD read,
+ tmp;
+ BYTE Channels4Raw=0;
+
+ if(!(mi->aacFile=fopen(lpstrFilename,"rb")))
+ return ERROR_getInfos("Error opening file");
+
+ // use bufferized stream
+ setvbuf(mi->aacFile,NULL,_IOFBF,32767);
+
+ // get size of file
+ fseek(mi->aacFile, 0, SEEK_END);
+ mi->src_size=ftell(mi->aacFile);
+ fseek(mi->aacFile, 0, SEEK_SET);
+
+ if(!(mi->buffer=(BYTE *)malloc(FAAD_STREAMSIZE)))
+ return ERROR_getInfos("Memory allocation error: mi->buffer");
+
+ tmp=mi->src_size<FAAD_STREAMSIZE ? mi->src_size : FAAD_STREAMSIZE;
+ read=fread(mi->buffer, 1, tmp, mi->aacFile);
+ if(read==tmp)
+ {
+ mi->bytes_read=read;
+ mi->bytes_into_buffer=read;
+ }
+ else
+ return ERROR_getInfos("Read failed!");
+
+ // skip Tag
+ long tagsize;
+ if(tagsize=id3v2_TagSize(mi->buffer))
+ {
+ if(tagsize>(long)mi->src_size)
+ ERROR_getInfos("Corrupt stream!");
+ if(tagsize<mi->bytes_into_buffer)
+ {
+ mi->bytes_into_buffer-=tagsize;
+ memcpy(mi->buffer,mi->buffer+tagsize,mi->bytes_into_buffer);
+ }
+ else
+ {
+ mi->bytes_read=tagsize;
+ mi->bytes_into_buffer=0;
+ if(tagsize>mi->bytes_into_buffer)
+ fseek(mi->aacFile, tagsize, SEEK_SET);
+ }
+ if(mi->src_size<mi->bytes_read+FAAD_STREAMSIZE-mi->bytes_into_buffer)
+ tmp=mi->src_size-mi->bytes_read;
+ else
+ tmp=FAAD_STREAMSIZE-mi->bytes_into_buffer;
+ read=fread(mi->buffer+mi->bytes_into_buffer, 1, tmp, mi->aacFile);
+ if(read==tmp)
+ {
+ mi->bytes_read+=read;
+ mi->bytes_into_buffer+=read;
+ }
+ else
+ ERROR_getInfos("Read failed!");
+ }
+
+ if(get_AAC_format(lpstrFilename, &mi->file_info, &mi->seek_table, &mi->seek_table_length, 0))
+ ERROR_getInfos("get_AAC_format()");
+ mi->IsSeekable=mi->file_info.headertype==ADTS && mi->seek_table && mi->seek_table_length>0;
+ mi->LockSeeking=!mi->IsSeekable;
+/*
+ aac_buffer b;
+ float fLength;
+ DWORD headertype;
+ b.infile=mi->aacFile;
+ b.buffer=mi->buffer;
+ b.bytes_into_buffer=read;
+ b.bytes_consumed=mi->bytes_consumed;
+ b.file_offset=0;
+ b.at_eof=(read!=tmp) ? 1 : 0;
+ GetAACInfos(&b,&headertype,&fLength,&mi->file_info.bitrate,mi->src_size);
+ mi->file_info.bitrate*=1024;
+ mi->file_info.headertype=headertype;
+ mi->bytes_into_buffer=b.bytes_into_buffer;
+ mi->bytes_consumed=b.bytes_consumed;
+ IsSeekable=false; // only mp4 can be seeked
+*/
+ if(!mi->FindBitrate) // open a new instance to get info from decoder
+ {
+ MYINPUT *miTmp;
+ Cfaad *NewInst;
+ if(!(NewInst=new Cfaad()))
+ return ERROR_getInfos("Memory allocation error: NewInst");
+
+ GLOBALLOCK(miTmp,NewInst->hInput,MYINPUT,return 0);
+ miTmp->FindBitrate=TRUE;
+ NewInst->ShowDlg4RawAAC=ShowDlg4RawAAC;
+ NewInst->pCfg=pCfg;
+ if(!NewInst->getInfos(lpstrFilename))
+ return ERROR_getInfos(0);
+ mi->Channels=miTmp->frameInfo.channels;
+ if(mi->file_info.headertype==RAW)
+ mi->file_info.bitrate=miTmp->file_info.bitrate;//*mi->Channels;
+ mi->Samprate=miTmp->Samprate;
+ mi->file_info.headertype=miTmp->file_info.headertype;
+ mi->file_info.object_type=miTmp->file_info.object_type;
+ mi->file_info.version=miTmp->file_info.version;
+ GlobalUnlock(NewInst->hInput);
+ delete NewInst;
+ }
+
+ if(!(mi->hDecoder=faacDecOpen()))
+ return ERROR_getInfos("Can't open library");
+ if(mi->file_info.headertype==RAW)
+ if(pCfg)
+ setFaadCfg(mi->hDecoder,*pCfg);
+ else
+ setDefaultFaadCfg(mi->hDecoder,mi->FindBitrate);
+ BYTE Channels; // faacDecInit doesn't report correctly the number of channels in raw aac files
+ if((mi->bytes_consumed=faacDecInit(mi->hDecoder, mi->buffer, mi->bytes_into_buffer, &mi->Samprate, &Channels))<0)
+ return ERROR_getInfos("faacDecInit()");
+ mi->bytes_into_buffer-=mi->bytes_consumed;
+
+ if(mi->FindBitrate) // get info from decoder
+ {
+ DWORD Samples,
+ BytesConsumed;
+
+ if(!processData(hInput,0,0))
+ return ERROR_getInfos(0);
+ Samples=mi->frameInfo.samples/sizeof(short);
+ BytesConsumed=mi->frameInfo.bytesconsumed;
+ if(mi->file_info.headertype==RAW || !mi->file_info.bitrate)
+ mi->file_info.bitrate=(BytesConsumed*8*mi->Samprate)/(Samples*2);
+ if(!mi->file_info.bitrate)
+ return ERROR_getInfos("Can't determine the bitrate");
+ }
+
+ mi->len_ms=(DWORD)((mi->src_size<<3)/(mi->file_info.bitrate>>10));
+// mi->len_ms=(DWORD)((1000*((float)mi->src_size*8))/mi->file_info.bitrate);
+ }
+
+ if(mi->len_ms)
+ mi->dst_size=(DWORD)(mi->len_ms*((float)mi->Samprate/1000)*mi->Channels*(mi->BitsPerSample/8));
+ else
+ return ERROR_getInfos("Can't determine the length");
+
+ showInfo(mi);
+
+ GlobalUnlock(hInput);
+ return hInput;
+}
+// *********************************************************************************************
+
+int Cfaad::processData(HANDLE hInput, unsigned char far *bufout, long lBytes)
+{
+BYTE *buffer;
+DWORD BytesDecoded=0;
+char *sample_buffer=0;
+int read;
+MYINPUT *mi;
+
+ GLOBALLOCK(mi,hInput,MYINPUT,return 0);
+
+ if(mi->LockSeeking)
+ {
+ NoSeek();
+ mi->LockSeeking=false;
+ }
+
+ if(mi->IsMP4) // MP4 file --------------------------------------------------------------------------
+ {
+ unsigned __int32 buffer_size=0;
+ int rc;
+
+ if(newpos_ms>-1)
+ {
+ MP4Duration duration=MP4ConvertToTrackDuration(mi->mp4File,mi->track,newpos_ms,MP4_MSECS_TIME_SCALE);
+ MP4SampleId sampleId=MP4GetSampleIdFromTime(mi->mp4File,mi->track,duration,0);
+ mi->bytes_read=(DWORD)(((float)newpos_ms*mi->file_info.bitrate)/(8*1000));
+ if(seek(mi->bytes_read)) // update the slider
+ return ERROR_processData(0);
+ newpos_ms=-1;
+ }
+ do
+ {
+ buffer=NULL;
+ if(mi->sampleId>=mi->numSamples)
+ return ERROR_processData(0);
+
+ rc=MP4ReadSample(mi->mp4File, mi->track, mi->sampleId++, (unsigned __int8 **)&buffer, &buffer_size, NULL, NULL, NULL, NULL);
+ if(rc==0 || buffer==NULL)
+ {
+ FREE_ARRAY(buffer);
+ return ERROR_processData("MP4ReadSample()");
+ }
+
+ sample_buffer=(char *)faacDecDecode(mi->hDecoder,&mi->frameInfo,buffer,buffer_size);
+ BytesDecoded=mi->frameInfo.samples*sizeof(short);
+ if(BytesDecoded>(DWORD)lBytes)
+ BytesDecoded=lBytes;
+ memmove(bufout,sample_buffer,BytesDecoded);
+ FREE_ARRAY(buffer);
+ // to update the slider
+ mi->bytes_read+=buffer_size;
+ if(seek(mi->bytes_read))
+ return ERROR_processData(0);
+ }while(!BytesDecoded && !mi->frameInfo.error);
+ }
+ else // AAC file --------------------------------------------------------------------------
+ {
+ if(newpos_ms>-1)
+ {
+ if(mi->IsSeekable)
+ {
+ DWORD normalized=mi->len_ms/(mi->seek_table_length-1);
+ if(normalized<1000)
+ normalized=1000;
+ mi->bytes_read=mi->seek_table[newpos_ms/normalized];
+ fseek(mi->aacFile, mi->bytes_read, SEEK_SET);
+ if(seek(mi->bytes_read)) // update the slider
+ return ERROR_processData(0);
+ mi->bytes_into_buffer=0;
+ mi->bytes_consumed=FAAD_STREAMSIZE;
+ }
+ newpos_ms=-1;
+ }
+ buffer=mi->buffer;
+ do
+ {
+ if(mi->bytes_consumed>0)
+ {
+ if(mi->bytes_into_buffer)
+ memmove(buffer,buffer+mi->bytes_consumed,mi->bytes_into_buffer);
+
+ if(mi->bytes_read<mi->src_size)
+ {
+ int tmp;
+ if(mi->bytes_read+mi->bytes_consumed<mi->src_size)
+ tmp=mi->bytes_consumed;
+ else
+ tmp=mi->src_size-mi->bytes_read;
+ read=fread(buffer+mi->bytes_into_buffer, 1, tmp, mi->aacFile);
+ if(read==tmp)
+ {
+ mi->bytes_read+=read;
+ mi->bytes_into_buffer+=read;
+ }
+ }
+ else
+ if(mi->bytes_into_buffer)
+ memset(buffer+mi->bytes_into_buffer, 0, mi->bytes_consumed);
+
+ mi->bytes_consumed=0;
+
+ if( (mi->bytes_into_buffer>3 && !memcmp(mi->buffer, "TAG", 3)) ||
+ (mi->bytes_into_buffer>11 && !memcmp(mi->buffer, "LYRICSBEGIN", 11)) ||
+ (mi->bytes_into_buffer>8 && !memcmp(mi->buffer, "APETAGEX", 8)))
+ return ERROR_processData(0);
+ }
+
+ if(mi->bytes_into_buffer<1)
+ if(mi->bytes_read<mi->src_size)
+ return ERROR_processData("Buffer empty!");
+ else
+ return ERROR_processData(0);
+
+ sample_buffer=(char *)faacDecDecode(mi->hDecoder,&mi->frameInfo,buffer,mi->bytes_into_buffer);
+ BytesDecoded=mi->frameInfo.samples*sizeof(short);
+ if(bufout)
+ {
+ if(BytesDecoded>(DWORD)lBytes)
+ BytesDecoded=lBytes;
+ if(sample_buffer && BytesDecoded && !mi->frameInfo.error)
+ memmove(bufout,sample_buffer,BytesDecoded);
+ }
+ else // Data needed to decode Raw files
+ {
+ mi->Channels=mi->frameInfo.channels;
+ mi->file_info.object_type=mi->frameInfo.object_type;
+ }
+ mi->bytes_consumed+=mi->frameInfo.bytesconsumed;
+ mi->bytes_into_buffer-=mi->bytes_consumed;
+ }while(!BytesDecoded && !mi->frameInfo.error);
+ } // END AAC file --------------------------------------------------------------------------
+
+ if(mi->frameInfo.error)
+ return ERROR_processData((char *)faacDecGetErrorMessage(mi->frameInfo.error));
+
+ showProgress(mi);
+
+ GlobalUnlock(hInput);
+ return BytesDecoded;
+}
--- /dev/null
+++ b/common/Cfaac/Cfaad.h
@@ -1,0 +1,200 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#ifndef _Cfaad_H
+#define _Cfaad_H
+
+#include <mp4.h>
+#include <faac.h>
+
+#ifdef MAIN
+ #undef MAIN
+#endif
+#ifdef SSR
+ #undef SSR
+#endif
+#ifdef LTP
+ #undef LTP
+#endif
+
+#include <faad.h>
+extern "C" {
+ #include <aacinfo.h> // get_AAC_format()
+}
+#include "Defines.h"
+#include "CRegistry.h"
+#include "CTag.h"
+
+
+
+// *********************************************************************************************
+
+// make this higher to support files with more channels
+#define MAX_CHANNELS 6
+#if FAAD_MIN_STREAMSIZE<2048
+#undef FAAD_MIN_STREAMSIZE
+// 960 for LD or else 1024 (expanded to 2048 for HE-AAC)
+#define FAAD_MIN_STREAMSIZE 2048
+#endif
+
+#define FAAD_STREAMSIZE (FAAD_MIN_STREAMSIZE*MAX_CHANNELS)
+
+// -----------------------------------------------------------------------------------------------
+
+#define REG_DEFAULT "Default"
+#define REG_PROFILE "Profile"
+#define REG_SAMPLERATE "SampleRate"
+#define REG_BPS "Bps"
+#define REG_DOWNMATRIX "Downmatrix"
+#define REG_OLDADTS "Old ADTS"
+#define REG_DONTUPSAMPLESBR "Don\'t upsample implicit SBR"
+
+// *********************************************************************************************
+
+
+
+/* FAAD file buffering routines */
+/*typedef struct {
+ long bytes_into_buffer;
+ long bytes_consumed;
+ long file_offset;
+ unsigned char *buffer;
+ int at_eof;
+ FILE *infile;
+} aac_buffer;
+// -----------------------------------------------------------------------------------------------
+
+typedef struct {
+ int version;
+ int channels;
+ int sampling_rate;
+ int bitrate;
+ int length;
+ int object_type;
+ int headertype;
+} faadAACInfo;
+*/
+
+// *********************************************************************************************
+
+class CMyDecCfg
+{
+private:
+
+ bool SaveCfgOnDestroy;
+
+public:
+
+ CMyDecCfg(bool SaveOnDestroy=true) { getCfg(this); SaveCfgOnDestroy=SaveOnDestroy; }
+ virtual ~CMyDecCfg() { if(SaveCfgOnDestroy) setCfg(this); FreeCfg(this); }
+
+ void FreeCfg(CMyDecCfg *cfg) { cfg->Tag.FreeTag(); }
+ void FreeCfg() { this->Tag.FreeTag(); }
+ void getCfg(CMyDecCfg *cfg);
+ void getCfg() { getCfg(this); }
+ void setCfg(CMyDecCfg *cfg);
+ void setCfg() { setCfg(this); }
+
+ bool DefaultCfg;
+ BYTE Channels;
+ DWORD BitRate;
+ faacDecConfiguration DecCfg;
+ CMP4Tag Tag;
+};
+// -----------------------------------------------------------------------------------------------
+
+typedef struct input_tag // any special vars associated with input file
+{
+//MP4
+MP4FileHandle mp4File;
+MP4SampleId sampleId,
+ numSamples;
+int track;
+BYTE type;
+
+//AAC
+FILE *aacFile;
+DWORD src_size; // size of compressed file
+long tagsize;
+DWORD bytes_read; // from file
+long bytes_consumed; // from buffer by faadDecDecode
+long bytes_into_buffer;
+unsigned char *buffer;
+DWORD *seek_table;
+int seek_table_length;
+
+// Raw AAC
+BOOL FindBitrate;
+
+// GLOBAL
+faacDecHandle hDecoder;
+faadAACInfo file_info;
+faacDecFrameInfo frameInfo;
+DWORD len_ms; // length of file in milliseconds
+BYTE Channels;
+DWORD Samprate;
+WORD BitsPerSample;
+DWORD dst_size; // size of decoded file. Cooledit needs it to update its progress bar
+//char *src_name; // name of compressed file
+int IsMP4;
+bool LockSeeking,
+ IsSeekable;
+} MYINPUT;
+// -----------------------------------------------------------------------------------------------
+
+class Cfaad
+{
+private:
+ virtual int GetAACTrack(MP4FileHandle infile);
+ long id3v2_TagSize(unsigned char *buffer);
+/* long id3v2_TagSize(aac_buffer *b);
+ int fill_buffer(aac_buffer *b);
+ void advance_buffer(aac_buffer *b, int bytes);
+ int adts_parse(aac_buffer *b, int *bitrate, float *length);
+ void GetAACInfos(aac_buffer *b, DWORD *header_type, float *song_length, int *pbitrate, long filesize);
+*/
+ virtual void DisplayError(char *ProcName, char *str);
+ virtual HANDLE ERROR_getInfos(char *str) { DisplayError("getInfos", str); return NULL; }
+ virtual int ERROR_processData(char *str) { DisplayError("processData", str); return 0; }
+ virtual void showInfo(MYINPUT *mi) {}
+ virtual void showProgress(MYINPUT *mi) {}
+ virtual void setDefaultFaadCfg(faacDecHandle hDecoder, BOOL showDlg);
+ virtual void setFaadCfg(faacDecHandle hDecoder, CMyDecCfg Cfg);
+ virtual int seek(int newpos_bytes) { return 0; } // !=0 => error
+ virtual void NoSeek() {} // put here the code to block seeking of player
+
+public:
+ Cfaad(HANDLE hInput=NULL);
+ virtual ~Cfaad();
+
+ int (*ShowDlg4RawAAC)(); // set this to show your dialog (to decode raw aac files)
+ int IsMP4(LPSTR lpstrFilename);
+ inline bool CanSeek() { MYINPUT *mi; GLOBALLOCK(mi,hInput,MYINPUT,return 0); bool IsSeekable=mi->IsSeekable; GlobalUnlock(hInput); return IsSeekable; }
+// virtual void GetAACInfos(char *Filename, aac_buffer *b, DWORD *header_type, float *song_length, int *pbitrate);
+ virtual HANDLE getInfos(LPSTR lpstrFilename);
+ virtual int processData(HANDLE hInput, unsigned char far *bufout, long lBytes);
+
+// GLOBAL
+ long newpos_ms; // set this to change position
+ HANDLE hInput;
+ CMyDecCfg *pCfg; // set this to use your cfg (to decode raw aac files)
+};
+#endif
--- /dev/null
+++ b/common/Cfaac/DecDialog.cpp
@@ -1,0 +1,214 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include <windows.h>
+#include "resource.h"
+#include <Defines.h> // my defines
+#include "Cfaad.h"
+#include "DecDialog.h"
+#include "EncDialog.h"
+
+// *********************************************************************************************
+
+extern HINSTANCE hInstance;
+extern HBITMAP hBmBrowse;
+
+// -----------------------------------------------------------------------------------------------
+
+#ifndef FAAD_FMT_64BIT
+#define FAAD_FMT_64BIT 5
+#endif
+
+// *********************************************************************************************
+
+int ShowDlg4RawAAC()
+{
+ return DialogBoxParam((HINSTANCE)hInstance,(LPCSTR)MAKEINTRESOURCE(IDD_DECODER),(HWND)NULL, (DLGPROC)DialogMsgProcDec, 0);
+// return DialogBoxParam((HINSTANCE)hInstance,(LPCSTR)MAKEINTRESOURCE(IDD_DECODER),(HWND)hWnd, (DLGPROC)DialogMsgProcDec, (DWORD)&cfg);
+}
+
+// *********************************************************************************************
+
+#define INIT_CB(hWnd,nID,list,IdSelected) \
+{ \
+ for(int i=0; list[i]; i++) \
+ SendMessage(GetDlgItem(hWnd, nID), CB_ADDSTRING, 0, (LPARAM)list[i]); \
+ SendMessage(GetDlgItem(hWnd, nID), CB_SETCURSEL, IdSelected, 0); \
+}
+// -----------------------------------------------------------------------------------------------
+
+// EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_SSR), Enabled);
+#define DISABLE_CTRLS_DEC(Enabled) \
+{ \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_MAIN), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LOW), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_DOWNMATRIX), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_OLDADTS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_SAMPLERATE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), Enabled); \
+}
+// -----------------------------------------------------------------------------------------------
+
+BOOL DialogMsgProcDec(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
+{
+ switch(Message)
+ {
+ case WM_INITDIALOG:
+ {
+/* if(!lParam)
+ {
+ MessageBox(hWndDlg,"Pointer==NULL",0,MB_OK|MB_ICONSTOP);
+ EndDialog(hWndDlg, 0);
+ return TRUE;
+ }
+*/
+ char buf[50];
+ char *SampleRate[]={"6000","8000","16000","22050","32000","44100","48000","64000","88200","96000","192000",0},
+ *BitsPerSample[]={"16","24","32","32 bit FLOAT","64 bit FLOAT",0};
+ CMyDecCfg cfg(false);
+
+ SetWindowPos(GetDlgItem(hWndDlg,IDC_CHK_DEFAULTCFG),GetDlgItem(hWndDlg,IDC_GRP_DEFAULT),0,0,0,0,SWP_NOMOVE | SWP_NOSIZE);
+
+ INIT_CB(hWndDlg,IDC_CB_BITSPERSAMPLE,BitsPerSample,0);
+ INIT_CB(hWndDlg,IDC_CB_SAMPLERATE,SampleRate,5);
+ sprintf(buf,"%lu",cfg.DecCfg.defSampleRate);
+ SetDlgItemText(hWndDlg, IDC_CB_SAMPLERATE, buf);
+
+ switch(cfg.DecCfg.defObjectType)
+ {
+ case MAIN:
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,TRUE);
+ break;
+ case LC:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LOW,TRUE);
+ break;
+ case SSR:
+ CheckDlgButton(hWndDlg,IDC_RADIO_SSR,TRUE);
+ break;
+ case LTP:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,TRUE);
+ break;
+ case HE_AAC:
+ CheckDlgButton(hWndDlg,IDC_RADIO_HE,TRUE);
+ break;
+ }
+
+ switch(cfg.DecCfg.outputFormat)
+ {
+ case FAAD_FMT_16BIT:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_SETCURSEL, 0, 0);
+ break;
+ case FAAD_FMT_24BIT:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_SETCURSEL, 1, 0);
+ break;
+ case FAAD_FMT_32BIT:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_SETCURSEL, 2, 0);
+ break;
+ case FAAD_FMT_FLOAT:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_SETCURSEL, 3, 0);
+ break;
+ case FAAD_FMT_64BIT:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_SETCURSEL, 4, 0);
+ break;
+ }
+
+ CheckDlgButton(hWndDlg,IDC_CHK_DOWNMATRIX, cfg.DecCfg.downMatrix);
+ CheckDlgButton(hWndDlg,IDC_CHK_OLDADTS, cfg.DecCfg.useOldADTSFormat);
+
+ CheckDlgButton(hWndDlg,IDC_CHK_DEFAULTCFG, cfg.DefaultCfg);
+ DISABLE_CTRLS_DEC(!cfg.DefaultCfg);
+ }
+ break; // End of WM_INITDIALOG
+
+ case WM_CLOSE:
+ // Closing the Dialog behaves the same as Cancel
+ PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0);
+ break; // End of WM_CLOSE
+
+ case WM_COMMAND:
+ switch(LOWORD(wParam))
+ {
+ case IDC_CHK_DEFAULTCFG:
+ {
+ char Enabled=!IsDlgButtonChecked(hWndDlg,IDC_CHK_DEFAULTCFG);
+ DISABLE_CTRLS_DEC(Enabled);
+ }
+ break;
+
+ case IDOK:
+ {
+ CMyDecCfg cfg;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_MAIN))
+ cfg.DecCfg.defObjectType=MAIN;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_LOW))
+ cfg.DecCfg.defObjectType=LC;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_SSR))
+ cfg.DecCfg.defObjectType=SSR;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_LTP))
+ cfg.DecCfg.defObjectType=LTP;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_HE))
+ cfg.DecCfg.defObjectType=HE_AAC;
+ switch(SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITSPERSAMPLE), CB_GETCURSEL, 0, 0))
+ {
+ case 0:
+ cfg.DecCfg.outputFormat=FAAD_FMT_16BIT;
+ break;
+ case 1:
+ cfg.DecCfg.outputFormat=FAAD_FMT_24BIT;
+ break;
+ case 2:
+ cfg.DecCfg.outputFormat=FAAD_FMT_32BIT;
+ break;
+ case 3:
+ cfg.DecCfg.outputFormat=FAAD_FMT_FLOAT;
+ break;
+ case 4:
+ cfg.DecCfg.outputFormat=FAAD_FMT_64BIT;
+ break;
+ }
+
+ cfg.DecCfg.defSampleRate=GetDlgItemInt(hWndDlg, IDC_CB_SAMPLERATE, 0, FALSE);
+ cfg.DecCfg.downMatrix=IsDlgButtonChecked(hWndDlg,IDC_CHK_DOWNMATRIX) ? TRUE : FALSE;
+ cfg.DecCfg.useOldADTSFormat=IsDlgButtonChecked(hWndDlg,IDC_CHK_OLDADTS) ? TRUE : FALSE;
+ cfg.DefaultCfg=IsDlgButtonChecked(hWndDlg,IDC_CHK_DEFAULTCFG) ? TRUE : FALSE;
+
+ EndDialog(hWndDlg, (DWORD)TRUE);
+ }
+ break;
+
+ case IDCANCEL:
+ // Ignore data values entered into the controls
+ // and dismiss the dialog window returning FALSE
+ EndDialog(hWndDlg, (DWORD)FALSE);
+ break;
+
+ case IDC_BTN_ABOUT:
+ DialogBox((HINSTANCE)hInstance,(LPCSTR)MAKEINTRESOURCE(IDD_ABOUT), (HWND)hWndDlg, (DLGPROC)DialogMsgProcAbout);
+ break;
+ }
+ break; // End of WM_COMMAND
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+}
--- /dev/null
+++ b/common/Cfaac/DecDialog.h
@@ -1,0 +1,39 @@
+extern BOOL DialogMsgProcDec(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam);
+extern int ShowDlg4RawAAC();
+
+static const char* mpeg4AudioNames[]=
+{
+ "Raw PCM",
+ "AAC Main",
+ "AAC LC (Low Complexity)",
+ "AAC SSR",
+ "AAC LTP (Long Term Prediction)",
+ "AAC HE (High Efficiency)",
+ "AAC Scalable",
+ "TwinVQ",
+ "CELP",
+ "HVXC",
+ "Reserved",
+ "Reserved",
+ "TTSI",
+ "Main synthetic",
+ "Wavetable synthesis",
+ "General MIDI",
+ "Algorithmic Synthesis and Audio FX",
+// defined in MPEG-4 version 2
+ "ER AAC LC (Low Complexity)",
+ "Reserved",
+ "ER AAC LTP (Long Term Prediction)",
+ "ER AAC Scalable",
+ "ER TwinVQ",
+ "ER BSAC",
+ "ER AAC LD (Low Delay)",
+ "ER CELP",
+ "ER HVXC",
+ "ER HILN",
+ "ER Parametric",
+ "Reserved",
+ "Reserved",
+ "Reserved",
+ "Reserved"
+};
binary files /dev/null b/common/Cfaac/Email.bmp differ
--- /dev/null
+++ b/common/Cfaac/EncDialog.cpp
@@ -1,0 +1,945 @@
+/*
+CFAAC - set of classes to import/export .aac/.mp4 files
+Copyright (C) 2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+#include <windows.h>
+#include <shlobj.h> // Browse
+#include <shellapi.h> // ShellExecute
+#include <Commdlg.h>
+#include "resource.h"
+#include "Defines.h" // my defines
+#include "CTag.h"
+#include "Cfaac.h"
+#include "EncDialog.h"
+
+#include <commctrl.h>
+#include <id3v2tag.h>
+//#include <id3\globals.h> // ID3LIB_RELEASE
+
+// *********************************************************************************************
+
+#ifdef USE_OUTPUT_FOLDER
+extern char config_AACoutdir[MAX_PATH];
+#endif
+
+extern HINSTANCE hInstance;
+extern HBITMAP hBmBrowse;
+
+// *********************************************************************************************
+
+/*
+DWORD PackCfg(MY_ENC_CFG *cfg)
+{
+DWORD dwOptions=0;
+
+ if(cfg->AutoCfg)
+ dwOptions=1<<31;
+ dwOptions|=(DWORD)cfg->EncCfg.mpegVersion<<30;
+ dwOptions|=(DWORD)cfg->EncCfg.aacObjectType<<28;
+ dwOptions|=(DWORD)cfg->EncCfg.allowMidside<<27;
+ dwOptions|=(DWORD)cfg->EncCfg.useTns<<26;
+ dwOptions|=(DWORD)cfg->EncCfg.useLfe<<25;
+ dwOptions|=(DWORD)cfg->EncCfg.outputFormat<<24;
+ if(cfg->UseQuality)
+ dwOptions|=(((DWORD)cfg->EncCfg.quantqual>>1)&0xff)<<16; // [2,512]
+ else
+ dwOptions|=(((DWORD)cfg->EncCfg.bitRate>>1)&0xff)<<16; // [2,512]
+ if(cfg->UseQuality)
+ dwOptions|=1<<15;
+ dwOptions|=((DWORD)cfg->EncCfg.bandWidth>>1)&&0x7fff; // [0,65536]
+
+ return dwOptions;
+}
+// -----------------------------------------------------------------------------------------------
+
+void UnpackCfg(MY_ENC_CFG *cfg, DWORD dwOptions)
+{
+ cfg->AutoCfg=dwOptions>>31;
+ cfg->EncCfg.mpegVersion=(dwOptions>>30)&1;
+ cfg->EncCfg.aacObjectType=(dwOptions>>28)&3;
+ cfg->EncCfg.allowMidside=(dwOptions>>27)&1;
+ cfg->EncCfg.useTns=(dwOptions>>26)&1;
+ cfg->EncCfg.useLfe=(dwOptions>>25)&1;
+ cfg->EncCfg.outputFormat=(dwOptions>>24)&1;
+ cfg->EncCfg.bitRate=((dwOptions>>16)&0xff)<<1;
+ cfg->UseQuality=(dwOptions>>15)&1;
+ cfg->EncCfg.bandWidth=(dwOptions&0x7fff)<<1;
+}*/
+// -----------------------------------------------------------------------------------------------
+
+#define INIT_CB(hWnd,nID,list,FillList,IdSelected) \
+{ \
+ if(FillList) \
+ for(int i=0; list[i]; i++) \
+ SendMessage(GetDlgItem(hWnd, nID), CB_ADDSTRING, 0, (LPARAM)list[i]); \
+ SendMessage(GetDlgItem(hWnd, nID), CB_SETCURSEL, IdSelected, 0); \
+}
+// -----------------------------------------------------------------------------------------------
+
+#define INIT_CB_GENRES(hWnd,nID,ID3Genres,IdSelected) \
+{ \
+ for(int i=0; i<(sizeof(ID3Genres)/sizeof(ID3Genres[0])); i++) \
+ SendMessage(GetDlgItem(hWnd, nID), CB_ADDSTRING, 0, (LPARAM)ID3Genres[i].name); \
+ SendMessage(GetDlgItem(hWnd, nID), CB_SETCURSEL, IdSelected, 0); \
+}
+// -----------------------------------------------------------------------------------------------
+
+#define DISABLE_LTP \
+{ \
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_MPEG2) && \
+ IsDlgButtonChecked(hWndDlg,IDC_RADIO_LTP)) \
+ { \
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,FALSE); \
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,TRUE); \
+ } \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), FALSE); \
+}
+// -----------------------------------------------------------------------------------------------
+
+// EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_SSR), Enabled);
+// EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_USELFE), Enabled);
+#define DISABLE_CTRLS_ENC(Enabled) \
+{ \
+ CheckDlgButton(hWndDlg,IDC_CHK_AUTOCFG, !Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_MPEG4), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_MPEG2), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_RAW), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_ADTS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_ALLOWMIDSIDE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_USETNS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_USELFE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_QUALITY), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_BITRATE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_BANDWIDTH), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_QUALITY), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_BITRATE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_MAIN), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LOW), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), Enabled); \
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_MPEG4)) \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), Enabled); \
+ else \
+ DISABLE_LTP \
+}
+// -----------------------------------------------------------------------------------------------
+
+#define ENABLE_TAG(Enabled) \
+{ \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_ARTIST), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_TITLE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_ALBUM), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_YEAR), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CB_GENRE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_WRITER), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_COMMENT), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_COMPILATION), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_COMPILATION), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_TRACK), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_NTRACKS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_DISK), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_NDISKS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_ARTFILE), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_BTN_ARTFILE), Enabled); \
+}
+// -----------------------------------------------------------------------------------------------
+
+#define ENABLE_AACTAGS(Enabled) \
+{ \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_COMPILATION), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_CHK_COMPILATION), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_NTRACKS), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_DISK), Enabled); \
+ EnableWindow(GetDlgItem(hWndDlg, IDC_E_NDISKS), Enabled); \
+}
+// -----------------------------------------------------------------------------------------------
+
+#ifdef USE_OUTPUT_FOLDER
+static int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
+{
+ if (uMsg == BFFM_INITIALIZED)
+ {
+ SetWindowText(hwnd,"Select folder");
+ SendMessage(hwnd,BFFM_SETSELECTION,(WPARAM)TRUE,(LPARAM)lpData);
+ }
+ return 0;
+}
+#else
+ #ifdef USE_IMPORT_TAG
+ static int CALLBACK BrowseCallbackProc(HWND hwnd, UINT uMsg, LPARAM lParam, LPARAM lpData)
+ {
+ if (uMsg == BFFM_INITIALIZED)
+ {
+ SetWindowText(hwnd,"Select folder");
+ SendMessage(hwnd,BFFM_SETSELECTION,(WPARAM)TRUE,(LPARAM)lpData);
+ }
+ return 0;
+ }
+ #endif
+#endif
+
+// -----------------------------------------------------------------------------------------------
+
+BOOL DialogMsgProcAbout(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
+{
+ switch(Message)
+ {
+ case WM_INITDIALOG:
+ {
+ char buf[512];
+ char *faac_id_string, *faac_copyright_string;
+
+ sprintf(buf,
+ APP_NAME " plugin " APP_VER " by Antonio Foranna\n\n"
+ "Libraries used:\n"
+ "\tlibfaac v%s\n"
+ "\tFAAD2 v" FAAD2_VERSION "\n"
+ "\t" PACKAGE " v" VERSION "\n"
+ "\tid3v2 \n\n" //"\t %s v %s \n\n"
+ "This code is given with FAAC package and does not contain executables.\n"
+ "This program is free software and can be distributed/modifyed under the terms of the GNU General Public License.\n"
+ "This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY.\n\n"
+ "Compiled on %s\n",
+ (faacEncGetVersion(&faac_id_string, &faac_copyright_string)==FAAC_CFG_VERSION) ? faac_id_string : " wrong libfaac version",
+// ID3LIB_FULL_NAME, ID3LIB_RELEASE,
+ __DATE__
+ );
+ SetDlgItemText(hWndDlg, IDC_L_ABOUT, buf);
+ }
+ break;
+ case WM_COMMAND:
+ switch(LOWORD(wParam))
+ {
+ case IDOK:
+ EndDialog(hWndDlg, TRUE);
+ break;
+ case IDCANCEL:
+ // Ignore data values entered into the controls and dismiss the dialog window returning FALSE
+ EndDialog(hWndDlg, FALSE);
+ break;
+ case IDC_AUDIOCODING:
+ ShellExecute(hWndDlg, NULL, "http://www.audiocoding.com", NULL, NULL, SW_SHOW);
+ break;
+ case IDC_MPEG4IP:
+ ShellExecute(hWndDlg, NULL, "http://www.mpeg4ip.net", NULL, NULL, SW_SHOW);
+ break;
+ case IDC_ID3:
+ ShellExecute(hWndDlg, NULL, "http://id3lib.sourceforge.net", NULL, NULL, SW_SHOW);
+ break;
+ case IDC_EMAIL:
+ ShellExecute(hWndDlg, NULL, "mailto:[email protected]", NULL, NULL, SW_SHOW);
+ break;
+ }
+ break;
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+}
+// -----------------------------------------------------------------------------------------------
+
+// ripped from id3v2tag.c
+ID3GENRES ID3Genres[]=
+{
+ 123, "Acapella",
+ 34, "Acid",
+ 74, "Acid Jazz",
+ 73, "Acid Punk",
+ 99, "Acoustic",
+ 20, "Alternative",
+ 40, "AlternRock",
+ 26, "Ambient",
+ 90, "Avantgarde",
+ 116, "Ballad",
+ 41, "Bass",
+ 85, "Bebob",
+ 96, "Big Band",
+ 89, "Bluegrass",
+ 0, "Blues",
+ 107, "Booty Bass",
+ 65, "Cabaret",
+ 88, "Celtic",
+ 104, "Chamber Music",
+ 102, "Chanson",
+ 97, "Chorus",
+ 61, "Christian Rap",
+ 1, "Classic Rock",
+ 32, "Classical",
+ 112, "Club",
+ 57, "Comedy",
+ 2, "Country",
+ 58, "Cult",
+ 3, "Dance",
+ 125, "Dance Hall",
+ 50, "Darkwave",
+ 254, "Data",
+ 22, "Death Metal",
+ 4, "Disco",
+ 55, "Dream",
+ 122, "Drum Solo",
+ 120, "Duet",
+ 98, "Easy Listening",
+ 52, "Electronic",
+ 48, "Ethnic",
+ 124, "Euro-House",
+ 25, "Euro-Techno",
+ 54, "Eurodance",
+ 84, "Fast Fusion",
+ 80, "Folk",
+ 81, "Folk-Rock",
+ 115, "Folklore",
+ 119, "Freestyle",
+ 5, "Funk",
+ 30, "Fusion",
+ 36, "Game",
+ 59, "Gangsta",
+ 38, "Gospel",
+ 49, "Gothic",
+ 91, "Gothic Rock",
+ 6, "Grunge",
+ 79, "Hard Rock",
+ 7, "Hip-Hop",
+ 35, "House",
+ 100, "Humour",
+ 19, "Industrial",
+ 33, "Instrumental",
+ 46, "Instrumental Pop",
+ 47, "Instrumental Rock",
+ 8, "Jazz",
+ 29, "Jazz+Funk",
+ 63, "Jungle",
+ 86, "Latin",
+ 71, "Lo-Fi",
+ 45, "Meditative",
+ 9, "Metal",
+ 77, "Musical",
+ 82, "National Folk",
+ 64, "Native American",
+ 10, "New Age",
+ 66, "New Wave",
+ 39, "Noise",
+ 255, "Not Set",
+ 11, "Oldies",
+ 103, "Opera",
+ 12, "Other",
+ 75, "Polka",
+ 13, "Pop",
+ 62, "Pop/Funk",
+ 53, "Pop-Folk",
+ 109, "Porn Groove",
+ 117, "Power Ballad",
+ 23, "Pranks",
+ 108, "Primus",
+ 92, "Progressive Rock",
+ 67, "Psychadelic",
+ 93, "Psychedelic Rock",
+ 43, "Punk",
+ 121, "Punk Rock",
+ 14, "R&B",
+ 15, "Rap",
+ 68, "Rave",
+ 16, "Reggae",
+ 76, "Retro",
+ 87, "Revival",
+ 118, "Rhythmic Soul",
+ 17, "Rock",
+ 78, "Rock & Roll",
+ 114, "Samba",
+ 110, "Satire",
+ 69, "Showtunes",
+ 21, "Ska",
+ 111, "Slow Jam",
+ 95, "Slow Rock",
+ 105, "Sonata",
+ 42, "Soul",
+ 37, "Sound Clip",
+ 24, "Soundtrack",
+ 56, "Southern Rock",
+ 44, "Space",
+ 101, "Speech",
+ 83, "Swing",
+ 94, "Symphonic Rock",
+ 106, "Symphony",
+ 113, "Tango",
+ 18, "Techno",
+ 51, "Techno-Industrial",
+ 60, "Top 40",
+ 70, "Trailer",
+ 31, "Trance",
+ 72, "Tribal",
+ 27, "Trip-Hop",
+ 28, "Vocal"
+};
+
+BOOL CALLBACK DIALOGMsgProcEnc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam)
+{
+ switch(Message)
+ {
+ case WM_INITDIALOG:
+ {
+ char buf[50];
+ char FillList=wParam||lParam ? 1 : 0;
+ char *Quality[]={"Default (100)","10","20","30","40","50","60","70","80","90","100","110","120","130","140","150","200","300","400","500",0};
+ char *BitRate[]={"Auto","8","16","18","20","24","32","40","48","56","64","80","96","112","128","160","192","224","256","320","384",0};
+ char *BandWidth[]={"Auto","Full","4000","8000","11025","16000","22050","24000","32000","44100","48000",0};
+ char *Ext[]={".aac",".mp4",".m4a",".m4b",0};
+ CMyEncCfg cfg(false);
+
+// sprintf(Quality[0]+8,"%3d",3);
+
+ SetWindowPos(GetDlgItem(hWndDlg,IDC_CHK_TAG),GetDlgItem(hWndDlg,IDC_GRP_TAG),0,0,0,0,SWP_NOMOVE | SWP_NOSIZE);
+
+ INIT_CB(hWndDlg,IDC_CB_QUALITY,Quality,FillList,0);
+ INIT_CB(hWndDlg,IDC_CB_BITRATE,BitRate,FillList,0);
+ INIT_CB(hWndDlg,IDC_CB_BANDWIDTH,BandWidth,FillList,0);
+ INIT_CB(hWndDlg,IDC_CB_EXT,Ext,FillList,0);
+
+ INIT_CB_GENRES(hWndDlg,IDC_CB_GENRE,ID3Genres,0);
+
+ SendMessage(GetDlgItem(hWndDlg, IDC_BTN_ARTFILE), BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) hBmBrowse);
+#ifdef USE_OUTPUT_FOLDER
+ SendMessage(GetDlgItem(hWndDlg, IDC_BTN_BROWSE), BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) hBmBrowse);
+ if(!cfg.OutDir || !*cfg.OutDir)
+ {
+ GetCurrentDirectory(MAX_PATH,config_AACoutdir);
+ FREE_ARRAY(cfg.OutDir);
+ cfg.OutDir=strdup(config_AACoutdir);
+ }
+ else
+ strcpy(config_AACoutdir,cfg.OutDir);
+ SetDlgItemText(hWndDlg, IDC_E_BROWSE, cfg.OutDir);
+#else
+ ShowWindow(GetDlgItem(hWndDlg, IDC_BTN_BROWSE),SW_HIDE);
+ ShowWindow(GetDlgItem(hWndDlg, IDC_E_BROWSE),SW_HIDE);
+ ShowWindow(GetDlgItem(hWndDlg, IDC_L_BROWSE),SW_HIDE);
+#endif
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG4,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG2,FALSE);
+ if(cfg.EncCfg.mpegVersion==MPEG4)
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG4,TRUE);
+ else
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG2,TRUE);
+
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_LOW,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_SSR,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,FALSE);
+ switch(cfg.EncCfg.aacObjectType)
+ {
+ case MAIN:
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,TRUE);
+ break;
+ case LOW:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LOW,TRUE);
+ break;
+ case SSR:
+ CheckDlgButton(hWndDlg,IDC_RADIO_SSR,TRUE);
+ break;
+ case LTP:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,TRUE);
+ DISABLE_LTP
+ break;
+ }
+
+ CheckDlgButton(hWndDlg,IDC_RADIO_RAW,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_ADTS,FALSE);
+ switch(cfg.EncCfg.outputFormat)
+ {
+ case RAW:
+ CheckDlgButton(hWndDlg,IDC_RADIO_RAW,TRUE);
+ break;
+ case ADTS:
+ CheckDlgButton(hWndDlg,IDC_RADIO_ADTS,TRUE);
+ break;
+ }
+
+ CheckDlgButton(hWndDlg, IDC_CHK_ALLOWMIDSIDE, cfg.EncCfg.allowMidside);
+ CheckDlgButton(hWndDlg, IDC_CHK_USETNS, cfg.EncCfg.useTns);
+ CheckDlgButton(hWndDlg, IDC_CHK_USELFE, cfg.EncCfg.useLfe);
+
+ if(cfg.UseQuality)
+ CheckDlgButton(hWndDlg,IDC_RADIO_QUALITY,TRUE);
+ else
+ CheckDlgButton(hWndDlg,IDC_RADIO_BITRATE,TRUE);
+
+ switch(cfg.EncCfg.quantqual)
+ {
+ case 100:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_QUALITY), CB_SETCURSEL, 0, 0);
+ break;
+ default:
+ if(cfg.EncCfg.quantqual<10)
+ cfg.EncCfg.quantqual=10;
+ if(cfg.EncCfg.quantqual>500)
+ cfg.EncCfg.quantqual=500;
+ sprintf(buf,"%lu",cfg.EncCfg.quantqual);
+ SetDlgItemText(hWndDlg, IDC_CB_QUALITY, buf);
+ break;
+ }
+ switch(cfg.EncCfg.bitRate)
+ {
+ case 0:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITRATE), CB_SETCURSEL, 0, 0);
+ break;
+ default:
+ sprintf(buf,"%lu",cfg.EncCfg.bitRate);
+ SetDlgItemText(hWndDlg, IDC_CB_BITRATE, buf);
+ break;
+ }
+ switch(cfg.EncCfg.bandWidth)
+ {
+ case 0:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BANDWIDTH), CB_SETCURSEL, 0, 0);
+ break;
+ case 0xffffffff:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BANDWIDTH), CB_SETCURSEL, 1, 0);
+ break;
+ default:
+ sprintf(buf,"%lu",cfg.EncCfg.bandWidth);
+ SetDlgItemText(hWndDlg, IDC_CB_BANDWIDTH, buf);
+ break;
+ }
+
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_EXT), CB_SETCURSEL, cfg.SaveMP4, 0);
+
+ if(wParam|lParam)
+ {
+ CheckDlgButton(hWndDlg,IDC_CHK_AUTOCFG, cfg.AutoCfg);
+ DISABLE_CTRLS_ENC(!cfg.AutoCfg);
+ }
+#ifdef USE_IMPORT_TAG
+ CheckDlgButton(hWndDlg,IDC_CHK_IMPORTTAG, cfg.TagImport);
+ cfg.TagImport=IsDlgButtonChecked(hWndDlg,IDC_CHK_IMPORTTAG) ? 1 : 0;
+ ShowWindow(GetDlgItem(hWndDlg, IDC_CHK_IMPORTTAG),SW_SHOW);
+ #ifdef USE_PATHEXT
+ SetDlgItemText(hWndDlg, IDC_E_SOURCEPATH, cfg.TagSrcPath);
+ SetDlgItemText(hWndDlg, IDC_E_SOURCEEXT, cfg.TagSrcExt);
+ SendMessage(GetDlgItem(hWndDlg, IDC_BTN_BROWSEIMPORT), BM_SETIMAGE, IMAGE_BITMAP, (LPARAM) hBmBrowse);
+ ShowWindow(GetDlgItem(hWndDlg, IDC_E_SOURCEEXT),SW_SHOW);
+ ShowWindow(GetDlgItem(hWndDlg, IDC_E_SOURCEPATH),SW_SHOW);
+ ShowWindow(GetDlgItem(hWndDlg, IDC_BTN_BROWSEIMPORT),SW_SHOW);
+ #endif
+#endif
+ CheckDlgButton(hWndDlg,IDC_CHK_TAG, cfg.TagOn);
+ ENABLE_TAG(cfg.TagOn && !cfg.TagImport);
+ ENABLE_AACTAGS(cfg.TagOn && !cfg.TagImport && cfg.SaveMP4);
+ SetDlgItemText(hWndDlg, IDC_E_ARTIST, cfg.Tag.artist);
+ SetDlgItemText(hWndDlg, IDC_E_TITLE, cfg.Tag.title);
+ SetDlgItemText(hWndDlg, IDC_E_ALBUM, cfg.Tag.album);
+ SetDlgItemText(hWndDlg, IDC_E_YEAR, cfg.Tag.year);
+ SetDlgItemText(hWndDlg, IDC_CB_GENRE, cfg.Tag.genre);
+ SetDlgItemText(hWndDlg, IDC_E_WRITER, cfg.Tag.writer);
+ SetDlgItemText(hWndDlg, IDC_E_COMMENT, cfg.Tag.comment);
+ SetDlgItemText(hWndDlg, IDC_E_ARTFILE, cfg.Tag.artFilename);
+ SetDlgItemInt(hWndDlg, IDC_E_TRACK, cfg.Tag.trackno, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_E_NTRACKS, cfg.Tag.ntracks, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_E_DISK, cfg.Tag.discno, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_E_NDISKS, cfg.Tag.ndiscs, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_E_COMPILATION, cfg.Tag.compilation, FALSE);
+ CheckDlgButton(hWndDlg, IDC_CHK_COMPILATION, cfg.Tag.compilation);
+ }
+ break; // End of WM_INITDIALOG
+
+ case WM_CLOSE:
+ // Closing the Dialog behaves the same as Cancel
+ PostMessage(hWndDlg, WM_COMMAND, IDCANCEL, 0L);
+ break; // End of WM_CLOSE
+
+ case WM_COMMAND:
+ switch(LOWORD(wParam))
+ {
+ case IDOK:
+ {
+// HANDLE hCfg=(HANDLE)lParam;
+ char buf[50];
+ CMyEncCfg cfg;
+
+ cfg.AutoCfg=IsDlgButtonChecked(hWndDlg,IDC_CHK_AUTOCFG) ? TRUE : FALSE;
+ if(!cfg.AutoCfg)
+ {
+ cfg.EncCfg.mpegVersion=IsDlgButtonChecked(hWndDlg,IDC_RADIO_MPEG4) ? MPEG4 : MPEG2;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_MAIN))
+ cfg.EncCfg.aacObjectType=MAIN;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_LOW))
+ cfg.EncCfg.aacObjectType=LOW;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_SSR))
+ cfg.EncCfg.aacObjectType=SSR;
+ if(IsDlgButtonChecked(hWndDlg,IDC_RADIO_LTP))
+ cfg.EncCfg.aacObjectType=LTP;
+ cfg.EncCfg.allowMidside=IsDlgButtonChecked(hWndDlg, IDC_CHK_ALLOWMIDSIDE);
+ cfg.EncCfg.useTns=IsDlgButtonChecked(hWndDlg, IDC_CHK_USETNS);
+ cfg.EncCfg.useLfe=IsDlgButtonChecked(hWndDlg, IDC_CHK_USELFE);
+
+ GetDlgItemText(hWndDlg, IDC_CB_BITRATE, buf, 50);
+ switch(*buf)
+ {
+ case 'A': // Auto
+ cfg.EncCfg.bitRate=0;
+ break;
+ default:
+ cfg.EncCfg.bitRate=GetDlgItemInt(hWndDlg, IDC_CB_BITRATE, 0, FALSE);
+ }
+ GetDlgItemText(hWndDlg, IDC_CB_BANDWIDTH, buf, 50);
+ switch(*buf)
+ {
+ case 'A': // Auto
+ cfg.EncCfg.bandWidth=0;
+ break;
+ case 'F': // Full
+ cfg.EncCfg.bandWidth=0xffffffff;
+ break;
+ default:
+ cfg.EncCfg.bandWidth=GetDlgItemInt(hWndDlg, IDC_CB_BANDWIDTH, 0, FALSE);
+ }
+ cfg.UseQuality=IsDlgButtonChecked(hWndDlg,IDC_RADIO_QUALITY) ? TRUE : FALSE;
+ GetDlgItemText(hWndDlg, IDC_CB_QUALITY, buf, 50);
+ switch(*buf)
+ {
+ case 'D': // Default
+ cfg.EncCfg.quantqual=100;
+ break;
+ default:
+ cfg.EncCfg.quantqual=GetDlgItemInt(hWndDlg, IDC_CB_QUALITY, 0, FALSE);
+ }
+ }
+
+ cfg.EncCfg.outputFormat=IsDlgButtonChecked(hWndDlg,IDC_RADIO_RAW) ? RAW : ADTS;
+#ifdef USE_OUTPUT_FOLDER
+ GetDlgItemText(hWndDlg, IDC_E_BROWSE, config_AACoutdir, MAX_PATH);
+ FREE_ARRAY(cfg.OutDir);
+ cfg.OutDir=strdup(config_AACoutdir);
+#endif
+ cfg.SaveMP4=(BYTE)SendMessage(GetDlgItem(hWndDlg, IDC_CB_EXT), CB_GETCURSEL, 0, 0);
+
+ cfg.TagOn=IsDlgButtonChecked(hWndDlg,IDC_CHK_TAG) ? 1 : 0;
+ char buffer[MAX_PATH];
+#ifdef USE_IMPORT_TAG
+ cfg.TagImport=IsDlgButtonChecked(hWndDlg,IDC_CHK_IMPORTTAG) ? 1 : 0;
+ #ifdef USE_PATHEXT
+ GetDlgItemText(hWndDlg, IDC_E_SOURCEPATH, buffer, MAX_PATH);
+ cfg.TagSrcPath=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_SOURCEEXT, buffer, MAX_PATH);
+ cfg.TagSrcExt=strdup(buffer);
+ #endif
+#endif
+ GetDlgItemText(hWndDlg, IDC_E_ARTIST, buffer, MAX_PATH);
+ cfg.Tag.artist=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_TITLE, buffer, MAX_PATH);
+ cfg.Tag.title=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_ALBUM, buffer, MAX_PATH);
+ cfg.Tag.album=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_YEAR, buffer, MAX_PATH);
+ cfg.Tag.year=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_CB_GENRE, buffer, MAX_PATH);
+ cfg.Tag.genre=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_WRITER, buffer, MAX_PATH);
+ cfg.Tag.writer=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_COMMENT, buffer, MAX_PATH);
+ cfg.Tag.comment=strdup(buffer);
+ GetDlgItemText(hWndDlg, IDC_E_ARTFILE, buffer, MAX_PATH);
+ cfg.Tag.artFilename=strdup(buffer);
+ cfg.Tag.trackno=GetDlgItemInt(hWndDlg, IDC_E_TRACK, 0, FALSE);
+ cfg.Tag.ntracks=GetDlgItemInt(hWndDlg, IDC_E_NTRACKS, 0, FALSE);
+ cfg.Tag.discno=GetDlgItemInt(hWndDlg, IDC_E_DISK, 0, FALSE);
+ cfg.Tag.ndiscs=GetDlgItemInt(hWndDlg, IDC_E_NDISKS, 0, FALSE);
+ cfg.Tag.compilation=(BYTE)GetDlgItemInt(hWndDlg, IDC_E_COMPILATION, 0, FALSE);
+ cfg.Tag.compilation=IsDlgButtonChecked(hWndDlg, IDC_CHK_COMPILATION) ? 1 : 0;
+ EndDialog(hWndDlg, TRUE);//(DWORD)hCfg);
+ }
+ break;
+
+ case IDCANCEL:
+ // Ignore data values entered into the controls
+ // and dismiss the dialog window returning FALSE
+ EndDialog(hWndDlg, FALSE);
+ break;
+
+ case IDC_BTN_ABOUT:
+ DialogBox((HINSTANCE)hInstance,(LPCSTR)MAKEINTRESOURCE(IDD_ABOUT), (HWND)hWndDlg, (DLGPROC)DialogMsgProcAbout);
+ break;
+
+ case IDC_BTN_LICENSE:
+ {
+ char *license =
+ "\nPlease note that the use of this software may require the payment of patent royalties.\n"
+ "You need to consider this issue before you start building derivative works.\n"
+ "We are not warranting or indemnifying you in any way for patent royalities!\n"
+ "YOU ARE SOLELY RESPONSIBLE FOR YOUR OWN ACTIONS!\n"
+ "\n"
+ "FAAC is based on the ISO MPEG-4 reference code. For this code base the\n"
+ "following license applies:\n"
+ "\n"
+/* "This software module was originally developed by\n"
+ "\n"
+ "FirstName LastName (CompanyName)\n"
+ "\n"
+ "and edited by\n"
+ "\n"
+ "FirstName LastName (CompanyName)\n"
+ "FirstName LastName (CompanyName)\n"
+ "\n"
+*/ "in the course of development of the MPEG-2 NBC/MPEG-4 Audio standard\n"
+ "ISO/IEC 13818-7, 14496-1,2 and 3. This software module is an\n"
+ "implementation of a part of one or more MPEG-2 NBC/MPEG-4 Audio tools\n"
+ "as specified by the MPEG-2 NBC/MPEG-4 Audio standard. ISO/IEC gives\n"
+ "users of the MPEG-2 NBC/MPEG-4 Audio standards free license to this\n"
+ "software module or modifications thereof for use in hardware or\n"
+ "software products claiming conformance to the MPEG-2 NBC/ MPEG-4 Audio\n"
+ "standards. Those intending to use this software module in hardware or\n"
+ "software products are advised that this use may infringe existing\n"
+ "patents. The original developer of this software module and his/her\n"
+ "company, the subsequent editors and their companies, and ISO/IEC have\n"
+ "no liability for use of this software module or modifications thereof\n"
+ "in an implementation. Copyright is not released for non MPEG-2\n"
+ "NBC/MPEG-4 Audio conforming products. The original developer retains\n"
+ "full right to use the code for his/her own purpose, assign or donate\n"
+ "the code to a third party and to inhibit third party from using the\n"
+ "code for non MPEG-2 NBC/MPEG-4 Audio conforming products. This\n"
+ "copyright notice must be included in all copies or derivative works.\n"
+ "\n"
+ "Copyright (c) 1997.\n"
+ "\n"
+ "For the changes made for the FAAC project the GNU Lesser General Public\n"
+ "License (LGPL), version 2 1991 applies:\n"
+ "\n"
+ "FAAC - Freeware Advanced Audio Coder\n"
+ "Copyright (C) 2001-2004 The individual contributors\n"
+ "\n"
+ "This library is free software; you can redistribute it and/or modify it under the terms of\n"
+ "the GNU Lesser General Public License as published by the Free Software Foundation;\n"
+ "either version 2.1 of the License, or (at your option) any later version.\n"
+ "\n"
+ "This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;\n"
+ "without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n"
+ "See the GNU Lesser General Public License for more details.\n"
+ "\n"
+ "You should have received a copy of the GNU Lesser General Public\n"
+ "License along with this library; if not, write to the Free Software\n"
+ "Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA\n";
+
+ MessageBox(hWndDlg,license,"FAAC libray License",MB_OK|MB_ICONINFORMATION);
+ }
+ break;
+
+#ifdef USE_OUTPUT_FOLDER
+ case IDC_BTN_BROWSE:
+ {
+ BROWSEINFO bi;
+ ITEMIDLIST *idlist;
+
+ GetDlgItemText(hWndDlg, IDC_E_BROWSE, config_AACoutdir, MAX_PATH);
+ bi.hwndOwner = hWndDlg;
+ bi.pidlRoot = 0;
+ bi.pszDisplayName = config_AACoutdir;
+ bi.lpszTitle = "Select a directory for aac/mp4 file output:";
+ bi.ulFlags = BIF_RETURNONLYFSDIRS;
+ bi.lpfn = BrowseCallbackProc;
+ bi.lParam = (LPARAM)config_AACoutdir;
+
+ idlist = SHBrowseForFolder(&bi);
+ if(idlist)
+ {
+ SHGetPathFromIDList(idlist, config_AACoutdir);
+ SetDlgItemText(hWndDlg, IDC_E_BROWSE, config_AACoutdir);
+ }
+ }
+ break;
+#endif
+ case IDC_BTN_ARTFILE:
+ {
+ OPENFILENAME ofn;
+ char ArtFilename[MAX_PATH]="";
+
+ GetDlgItemText(hWndDlg, IDC_E_ARTFILE, ArtFilename, MAX_PATH);
+ ofn.lStructSize = sizeof(OPENFILENAME);
+ ofn.hwndOwner = (HWND)hWndDlg;
+ ofn.lpstrFilter = "Cover art files (*.gif,*jpg,*.png)\0*.gif;*.jpg;*.png\0";
+ ofn.lpstrCustomFilter = NULL;
+ ofn.nFilterIndex = 1;
+ ofn.lpstrFile = ArtFilename;
+ ofn.nMaxFile = MAX_PATH; //sizeof ArtFilename;
+ ofn.lpstrFileTitle = NULL;
+ ofn.nMaxFileTitle = 0;
+ ofn.lpstrInitialDir = NULL;
+ ofn.lpstrTitle = "Select cover art file";
+ ofn.Flags = OFN_EXPLORER | OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_HIDEREADONLY | OFN_ENABLESIZING;
+ ofn.lpstrDefExt = NULL;//"jpg";
+ ofn.hInstance = hInstance;
+
+ if(GetOpenFileName(&ofn))
+ SetDlgItemText(hWndDlg, IDC_E_ARTFILE, ArtFilename);
+ }
+ break;
+
+#ifdef USE_IMPORT_TAG
+ case IDC_BTN_BROWSEIMPORT:
+ {
+ char path[MAX_PATH];
+ BROWSEINFO bi;
+ ITEMIDLIST *idlist;
+
+ GetDlgItemText(hWndDlg, IDC_E_SOURCEPATH, path, MAX_PATH);
+ bi.hwndOwner = hWndDlg;
+ bi.pidlRoot = 0;
+ bi.pszDisplayName = path;
+ bi.lpszTitle = "Select the folder where source files are stored:";
+ bi.ulFlags = BIF_RETURNONLYFSDIRS;
+ bi.lpfn = BrowseCallbackProc;
+ bi.lParam = (LPARAM)path;
+
+ idlist=SHBrowseForFolder(&bi);
+ if(idlist)
+ {
+ SHGetPathFromIDList(idlist, path);
+ SetDlgItemText(hWndDlg, IDC_E_SOURCEPATH, path);
+ }
+ }
+ break;
+#endif
+ case IDC_RADIO_MPEG4:
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), !IsDlgButtonChecked(hWndDlg,IDC_CHK_AUTOCFG));
+ break;
+
+ case IDC_RADIO_MPEG2:
+ EnableWindow(GetDlgItem(hWndDlg, IDC_RADIO_LTP), FALSE);
+ DISABLE_LTP
+ break;
+
+ case IDC_CHK_AUTOCFG:
+ {
+ BYTE Enabled=IsDlgButtonChecked(hWndDlg,IDC_CHK_AUTOCFG);
+ DISABLE_CTRLS_ENC(!Enabled);
+ if(!Enabled)
+ SendMessage(hWndDlg, WM_INITDIALOG, 0L, 0L);
+ else
+ {
+ SetDlgItemInt(hWndDlg, IDC_CB_QUALITY, DEF_QUALITY, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_CB_BITRATE, DEF_BITRATE, FALSE);
+ SetDlgItemInt(hWndDlg, IDC_CB_BANDWIDTH, DEF_BANDWIDTH, FALSE);
+
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG4,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG2,FALSE);
+ if(DEF_MPEGVER==MPEG4)
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG4,TRUE);
+ else
+ CheckDlgButton(hWndDlg,IDC_RADIO_MPEG2,TRUE);
+
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_LOW,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_SSR,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,FALSE);
+ switch(DEF_PROFILE)
+ {
+ case MAIN:
+ CheckDlgButton(hWndDlg,IDC_RADIO_MAIN,TRUE);
+ break;
+ case LOW:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LOW,TRUE);
+ break;
+ case SSR:
+ CheckDlgButton(hWndDlg,IDC_RADIO_SSR,TRUE);
+ break;
+ case LTP:
+ CheckDlgButton(hWndDlg,IDC_RADIO_LTP,TRUE);
+ DISABLE_LTP
+ break;
+ }
+
+ CheckDlgButton(hWndDlg,IDC_RADIO_RAW,FALSE);
+ CheckDlgButton(hWndDlg,IDC_RADIO_ADTS,FALSE);
+ switch(DEF_HEADER)
+ {
+ case RAW:
+ CheckDlgButton(hWndDlg,IDC_RADIO_RAW,TRUE);
+ break;
+ case ADTS:
+ CheckDlgButton(hWndDlg,IDC_RADIO_ADTS,TRUE);
+ break;
+ }
+
+ CheckDlgButton(hWndDlg, IDC_CHK_ALLOWMIDSIDE, DEF_MIDSIDE);
+ CheckDlgButton(hWndDlg, IDC_CHK_USETNS, DEF_TNS);
+ CheckDlgButton(hWndDlg, IDC_CHK_USELFE, DEF_LFE);
+
+ if(DEF_USEQUALTY)
+ CheckDlgButton(hWndDlg,IDC_RADIO_QUALITY,true);
+ else
+ CheckDlgButton(hWndDlg,IDC_RADIO_BITRATE,true);
+
+ if(DEF_QUALITY<10)
+ SetDlgItemInt(hWndDlg, IDC_CB_QUALITY, 10, FALSE);
+ else
+ if(DEF_QUALITY>500)
+ SetDlgItemInt(hWndDlg, IDC_CB_QUALITY, 500, FALSE);
+ else
+ SetDlgItemInt(hWndDlg, IDC_CB_QUALITY, DEF_QUALITY, FALSE);
+
+ switch(DEF_BITRATE)
+ {
+ case 0:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BITRATE), CB_SETCURSEL, 0, 0);
+// SetDlgItemInt(hWndDlg, IDC_CB_BITRATE, 128, FALSE);
+ break;
+ default:
+ SetDlgItemInt(hWndDlg, IDC_CB_BITRATE, DEF_BITRATE, FALSE);
+ break;
+ }
+ switch(DEF_BANDWIDTH)
+ {
+ case 0:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BANDWIDTH), CB_SETCURSEL, 0, 0);
+ break;
+ case 0xffffffff:
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_BANDWIDTH), CB_SETCURSEL, 1, 0);
+ break;
+ default:
+ SetDlgItemInt(hWndDlg, IDC_CB_BANDWIDTH, DEF_BANDWIDTH, FALSE);
+ break;
+ }
+
+ SendMessage(GetDlgItem(hWndDlg, IDC_CB_EXT), CB_SETCURSEL, DEF_WRITEMP4, 0);
+// DISABLE_CTRLS_ENC(!Enabled);
+ }
+ }
+ break;
+
+ case IDC_CHK_TAG:
+ case IDC_CB_EXT:
+ {
+ char TagImport=IsDlgButtonChecked(hWndDlg,IDC_CHK_IMPORTTAG);
+ char TagEnabled=IsDlgButtonChecked(hWndDlg,IDC_CHK_TAG);
+ ENABLE_TAG(TagEnabled && !TagImport);
+ char Enabled=SendMessage(GetDlgItem(hWndDlg, IDC_CB_EXT), CB_GETCURSEL, 0, 0)!=0;
+ ENABLE_AACTAGS(TagEnabled && !TagImport && Enabled);
+ }
+ break;
+#ifdef USE_IMPORT_TAG
+ case IDC_CHK_IMPORTTAG:
+ SendMessage(hWndDlg, WM_COMMAND, IDC_CHK_TAG, 0);
+ break;
+#endif
+ }
+ break; // End of WM_COMMAND
+ default:
+ return FALSE;
+ }
+
+ return TRUE;
+} // End of DIALOGSMsgProc
--- /dev/null
+++ b/common/Cfaac/EncDialog.h
@@ -1,0 +1,2 @@
+extern BOOL DialogMsgProcAbout(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam);
+extern BOOL CALLBACK DIALOGMsgProcEnc(HWND hWndDlg, UINT Message, WPARAM wParam, LPARAM lParam);
--- /dev/null
+++ b/common/Cfaac/FAAC.rc
@@ -1,0 +1,343 @@
+// Microsoft Visual C++ generated resource script.
+//
+#include "resource.h"
+
+#define APSTUDIO_READONLY_SYMBOLS
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 2 resource.
+//
+#include "afxres.h"
+
+/////////////////////////////////////////////////////////////////////////////
+#undef APSTUDIO_READONLY_SYMBOLS
+
+/////////////////////////////////////////////////////////////////////////////
+// English (U.S.) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ENU)
+#ifdef _WIN32
+LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_US
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_ENCODER DIALOGEX 0, 0, 338, 219
+STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION |
+ WS_SYSMENU
+CAPTION "MPEG4-AAC options"
+FONT 8, "MS Sans Serif", 0, 0, 0x0
+BEGIN
+ DEFPUSHBUTTON "&OK",IDOK,12,200,36,14
+ PUSHBUTTON "&Cancel",IDCANCEL,48,200,36,14
+ PUSHBUTTON "&About",IDC_BTN_ABOUT,84,200,36,14
+ PUSHBUTTON "&License",IDC_BTN_LICENSE,120,200,36,14
+ CONTROL "Automatic configuration",IDC_CHK_AUTOCFG,"Button",
+ BS_AUTOCHECKBOX | WS_TABSTOP,4,4,90,10
+ CONTROL "Main",IDC_RADIO_MAIN,"Button",BS_AUTORADIOBUTTON |
+ WS_GROUP,9,28,31,10
+ CONTROL "LC",IDC_RADIO_LOW,"Button",BS_AUTORADIOBUTTON,9,40,25,
+ 10
+ CONTROL "LTP",IDC_RADIO_LTP,"Button",BS_AUTORADIOBUTTON,9,52,29,
+ 10
+ CONTROL "SSR",IDC_RADIO_SSR,"Button",BS_AUTORADIOBUTTON | NOT
+ WS_VISIBLE | WS_DISABLED,9,63,31,10
+ CONTROL "MPEG4",IDC_RADIO_MPEG4,"Button",BS_AUTORADIOBUTTON |
+ WS_GROUP,62,27,40,10
+ CONTROL "MPEG2",IDC_RADIO_MPEG2,"Button",BS_AUTORADIOBUTTON,62,
+ 40,40,9
+ CONTROL "Raw",IDC_RADIO_RAW,"Button",BS_AUTORADIOBUTTON |
+ WS_GROUP,112,27,42,10
+ CONTROL "ADTS",IDC_RADIO_ADTS,"Button",BS_AUTORADIOBUTTON,112,40,
+ 41,9
+ CONTROL "Quality",IDC_RADIO_QUALITY,"Button",BS_AUTORADIOBUTTON |
+ WS_GROUP,9,84,37,10
+ COMBOBOX IDC_CB_QUALITY,102,81,48,97,CBS_DROPDOWN | WS_VSCROLL |
+ WS_GROUP | WS_TABSTOP
+ CONTROL "Bitrate",IDC_RADIO_BITRATE,"Button",BS_AUTORADIOBUTTON,
+ 9,100,36,10
+ COMBOBOX IDC_CB_BITRATE,102,97,48,86,CBS_DROPDOWN | WS_VSCROLL |
+ WS_TABSTOP
+ LTEXT "Cutoff",IDC_STATIC,21,121,20,8
+ COMBOBOX IDC_CB_BANDWIDTH,102,118,48,81,CBS_DROPDOWN | WS_VSCROLL |
+ WS_TABSTOP
+ LTEXT "Write",IDC_STATIC,22,138,18,8
+ COMBOBOX IDC_CB_EXT,102,135,48,81,CBS_DROPDOWNLIST | WS_VSCROLL |
+ WS_TABSTOP
+ CONTROL "Allow Mid/Side",IDC_CHK_ALLOWMIDSIDE,"Button",
+ BS_AUTOCHECKBOX | WS_TABSTOP,9,152,63,10
+ CONTROL "Use TNS",IDC_CHK_USETNS,"Button",BS_AUTOCHECKBOX | NOT
+ WS_VISIBLE | WS_DISABLED | WS_TABSTOP,9,162,45,10
+ CONTROL "Use LFE channel",IDC_CHK_USELFE,"Button",
+ BS_AUTOCHECKBOX | NOT WS_VISIBLE | WS_DISABLED |
+ WS_TABSTOP,88,152,67,10
+ EDITTEXT IDC_E_BROWSE,50,172,83,14,ES_AUTOHSCROLL
+ PUSHBUTTON "Browse",IDC_BTN_BROWSE,137,172,18,14,BS_BITMAP |
+ BS_FLAT
+ GROUPBOX "",IDC_GRP_TAG,160,4,174,210
+ CONTROL "Tag",IDC_CHK_TAG,"Button",BS_AUTOCHECKBOX | WS_TABSTOP,
+ 165,3,29,10
+ CONTROL "Import",IDC_CHK_IMPORTTAG,"Button",BS_AUTOCHECKBOX |
+ NOT WS_VISIBLE | WS_TABSTOP,165,15,35,10
+ EDITTEXT IDC_E_SOURCEPATH,207,11,63,14,ES_AUTOHSCROLL | NOT
+ WS_VISIBLE
+ PUSHBUTTON "Browse",IDC_BTN_BROWSEIMPORT,273,11,18,14,BS_BITMAP |
+ BS_FLAT | NOT WS_VISIBLE
+ EDITTEXT IDC_E_SOURCEEXT,294,11,34,14,ES_AUTOHSCROLL | NOT
+ WS_VISIBLE
+ EDITTEXT IDC_E_ARTIST,207,27,121,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_TITLE,207,42,121,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_ALBUM,207,57,121,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_YEAR,207,72,121,14,ES_AUTOHSCROLL
+ COMBOBOX IDC_CB_GENRE,207,87,121,161,CBS_DROPDOWN | WS_VSCROLL |
+ WS_TABSTOP
+ EDITTEXT IDC_E_WRITER,207,101,121,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_COMMENT,207,116,121,29,ES_MULTILINE |
+ ES_AUTOHSCROLL
+ EDITTEXT IDC_E_COMPILATION,207,146,121,14,ES_AUTOHSCROLL | NOT
+ WS_VISIBLE
+ CONTROL "Part of a compilation",IDC_CHK_COMPILATION,"Button",
+ BS_AUTOCHECKBOX | WS_TABSTOP,165,148,80,10
+ EDITTEXT IDC_E_TRACK,233,162,40,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_NTRACKS,288,162,40,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_DISK,233,177,40,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_NDISKS,288,177,40,14,ES_AUTOHSCROLL
+ EDITTEXT IDC_E_ARTFILE,207,192,98,14,ES_AUTOHSCROLL
+ PUSHBUTTON "&...",IDC_BTN_ARTFILE,311,192,17,14,BS_BITMAP | BS_FLAT
+ GROUPBOX "AAC type",IDC_STATIC,56,16,48,52
+ GROUPBOX "Profile",IDC_STATIC,4,16,48,52
+ GROUPBOX "Header",IDC_STATIC,108,16,48,52
+ GROUPBOX "Encoding mode",IDC_STATIC,4,73,152,42
+ LTEXT "Artist",IDC_STATIC,165,29,16,8
+ LTEXT "Title",IDC_STATIC,165,44,14,8
+ LTEXT "Album",IDC_STATIC,165,59,20,8
+ LTEXT "Year",IDC_STATIC,165,74,16,8
+ LTEXT "Genre",IDC_STATIC,165,89,20,8
+ LTEXT "Writer",IDC_STATIC,165,103,20,8
+ LTEXT "Comment\n(ctrl-Enter\nto go down)",IDC_STATIC,165,118,
+ 37,26
+ LTEXT "Track",IDC_STATIC,165,166,20,8
+ LTEXT "/",IDC_STATIC,277,166,8,8
+ LTEXT "Disk",IDC_STATIC,165,180,15,8
+ LTEXT "/",IDC_STATIC,277,180,8,8
+ LTEXT "Cover art file",IDC_STATIC,165,195,40,8
+ LTEXT "Output folder",IDC_L_BROWSE,4,175,42,8
+END
+
+IDD_DECODER DIALOGEX 0, 0, 162, 153
+STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION |
+ WS_SYSMENU
+CAPTION "Raw .AAC options"
+FONT 8, "MS Sans Serif", 0, 0, 0x1
+BEGIN
+ DEFPUSHBUTTON "&OK",IDOK,47,132,36,14
+ PUSHBUTTON "&Cancel",IDCANCEL,83,132,36,14
+ PUSHBUTTON "&About",IDC_BTN_ABOUT,119,132,36,14
+ CONTROL "Main",IDC_RADIO_MAIN,"Button",BS_AUTORADIOBUTTON |
+ WS_GROUP,19,33,31,10
+ CONTROL "Low",IDC_RADIO_LOW,"Button",BS_AUTORADIOBUTTON,19,44,29,
+ 10
+ CONTROL "SSR",IDC_RADIO_SSR,"Button",BS_AUTORADIOBUTTON |
+ WS_DISABLED,19,56,31,10
+ CONTROL "LTP",IDC_RADIO_LTP,"Button",BS_AUTORADIOBUTTON,19,68,29,
+ 10
+ GROUPBOX "Profile",IDC_STATIC,13,23,48,70
+ COMBOBOX IDC_CB_SAMPLERATE,72,74,69,87,CBS_DROPDOWN | WS_DISABLED |
+ WS_VSCROLL | WS_TABSTOP
+ CONTROL "Default settings",IDC_CHK_DEFAULTCFG,"Button",
+ BS_AUTOCHECKBOX | WS_TABSTOP,13,7,64,10
+ GROUPBOX "Sample rate",IDC_STATIC,66,61,81,32
+ CONTROL "HE",IDC_RADIO_HE,"Button",BS_AUTORADIOBUTTON |
+ WS_DISABLED,19,80,26,10
+ CONTROL "Down matrix 5.1 to 2 channels",IDC_CHK_DOWNMATRIX,
+ "Button",BS_AUTOCHECKBOX | WS_TABSTOP,13,98,111,10
+ CONTROL "Assume old ADTS format",IDC_CHK_OLDADTS,"Button",
+ BS_AUTOCHECKBOX | WS_TABSTOP,13,110,95,10
+ COMBOBOX IDC_CB_BITSPERSAMPLE,72,35,69,87,CBS_DROPDOWNLIST |
+ WS_DISABLED | WS_VSCROLL | WS_TABSTOP
+ GROUPBOX "Output bits per sample",IDC_STATIC,66,23,81,32
+ GROUPBOX "",IDC_GRP_DEFAULT,7,8,147,118
+END
+
+
+#ifdef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// TEXTINCLUDE
+//
+
+1 TEXTINCLUDE
+BEGIN
+ "resource.h\0"
+END
+
+2 TEXTINCLUDE
+BEGIN
+ "#include ""afxres.h""\r\n"
+ "\0"
+END
+
+3 TEXTINCLUDE
+BEGIN
+ "\r\n"
+ "\0"
+END
+
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO
+BEGIN
+ IDD_ENCODER, DIALOG
+ BEGIN
+ LEFTMARGIN, 4
+ RIGHTMARGIN, 334
+ TOPMARGIN, 4
+ BOTTOMMARGIN, 214
+ END
+
+ IDD_DECODER, DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 154
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 146
+ END
+END
+#endif // APSTUDIO_INVOKED
+
+#endif // English (U.S.) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+/////////////////////////////////////////////////////////////////////////////
+// Italian (Italy) resources
+
+#if !defined(AFX_RESOURCE_DLL) || defined(AFX_TARG_ITA)
+#ifdef _WIN32
+LANGUAGE LANG_ITALIAN, SUBLANG_ITALIAN
+#pragma code_page(1252)
+#endif //_WIN32
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Dialog
+//
+
+IDD_ABOUT DIALOGEX 0, 0, 191, 230
+STYLE DS_SETFONT | DS_MODALFRAME | WS_POPUP | WS_VISIBLE | WS_CAPTION
+CAPTION "About"
+FONT 8, "MS Sans Serif", 0, 0, 0x1
+BEGIN
+ DEFPUSHBUTTON "&OK",IDOK,145,208,39,14
+ CONTROL 104,IDC_AUDIOCODING,"Static",SS_BITMAP | SS_NOTIFY |
+ SS_SUNKEN,7,7,178,69
+ CONTROL 107,IDC_MPEG4IP,"Static",SS_BITMAP | SS_NOTIFY |
+ SS_SUNKEN,7,202,59,20
+ CONTROL 106,IDC_EMAIL,"Static",SS_BITMAP | SS_NOTIFY,96,204,43,
+ 18
+ LTEXT "Text",IDC_L_ABOUT,7,55,177,142
+ ICON IDI_ID3,IDC_ID3,70,202,20,20,SS_NOTIFY | SS_SUNKEN
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// DESIGNINFO
+//
+
+#ifdef APSTUDIO_INVOKED
+GUIDELINES DESIGNINFO
+BEGIN
+ IDD_ABOUT, DIALOG
+ BEGIN
+ LEFTMARGIN, 7
+ RIGHTMARGIN, 184
+ TOPMARGIN, 7
+ BOTTOMMARGIN, 222
+ END
+END
+#endif // APSTUDIO_INVOKED
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Bitmap
+//
+
+IDB_AUDIOCODING BITMAP "AudioCoding.bmp"
+IDB_EMAIL BITMAP "Email.bmp"
+IDB_MPEG4IP BITMAP "mpeg4ip-v.bmp"
+IDB_BROWSE BITMAP "Open.bmp"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Icon
+//
+
+// Icon with lowest ID value placed first to ensure application icon
+// remains consistent on all systems.
+IDI_ID3 ICON "id3v2.ico"
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,0,0
+ PRODUCTVERSION 1,0,0,0
+ FILEFLAGSMASK 0x17L
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x4L
+ FILETYPE 0x2L
+ FILESUBTYPE 0x0L
+BEGIN
+ BLOCK "StringFileInfo"
+ BEGIN
+ BLOCK "041004b0"
+ BEGIN
+ VALUE "FileDescription", "FAAC plugin"
+ VALUE "FileVersion", "1, 0, 0, 0"
+ VALUE "InternalName", "FAAC"
+ VALUE "LegalCopyright", "Copyright (C) 2004"
+ VALUE "OriginalFilename", "FAAC.dll"
+ VALUE "ProductName", " FAAC Dynamic Link Library"
+ VALUE "ProductVersion", "1, 0, 0, 0"
+ END
+ END
+ BLOCK "VarFileInfo"
+ BEGIN
+ VALUE "Translation", 0x410, 1200
+ END
+END
+
+#endif // Italian (Italy) resources
+/////////////////////////////////////////////////////////////////////////////
+
+
+
+#ifndef APSTUDIO_INVOKED
+/////////////////////////////////////////////////////////////////////////////
+//
+// Generated from the TEXTINCLUDE 3 resource.
+//
+
+
+/////////////////////////////////////////////////////////////////////////////
+#endif // not APSTUDIO_INVOKED
+
binary files /dev/null b/common/Cfaac/Open.bmp differ
--- /dev/null
+++ b/common/Cfaac/ReadMe.txt
@@ -1,0 +1,20 @@
++----------------------------------------------------------------+
+| |
+| Cfaac Readme |
+| ------------ |
+| |
++----------------------------------------------------------------+
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY.
+
+----------------------------------------------------------------------------
+
+Cfaac is a set of classes to develop plugins (to import/export .aac/.mp4 files) with ease.
+
+----------------------------------------------------------------------------
+
+For suggestions, bugs report, etc., you can contact me at
[email protected]
--- /dev/null
+++ b/common/Cfaac/TypeDef.h
@@ -1,0 +1,45 @@
+/*
+FAAC - codec plugin for Cooledit
+Copyright (C) 2002-2004 Antonio Foranna
+
+This program is free software; you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program; if not, write to the Free Software
+Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+The author can be contacted at:
[email protected]
+*/
+
+//---------------------------------------------------------------------------
+#ifndef TypeDefH
+#define TypeDefH
+//---------------------------------------------------------------------------
+
+/* typedef.h */
+
+#ifndef BYTE
+typedef unsigned char BYTE;
+#endif
+#ifndef WORD
+typedef unsigned short WORD;
+#endif
+#ifndef DWORD
+typedef unsigned long DWORD;
+#endif
+#ifndef QWORD
+typedef unsigned __int64 QWORD;
+#endif
+
+//---------------------------------------------------------------------------
+#endif
+//---------------------------------------------------------------------------
+
binary files /dev/null b/common/Cfaac/id3v2.ico differ
binary files /dev/null b/common/Cfaac/mpeg4ip-v.bmp differ
--- /dev/null
+++ b/common/Cfaac/resource.h
@@ -1,0 +1,81 @@
+//{{NO_DEPENDENCIES}}
+// Microsoft Visual C++ generated include file.
+// Used by FAAC.rc
+//
+#define IDD_ENCODER 101
+#define IDD_DECODER 102
+#define IDD_ABOUT 103
+#define IDB_AUDIOCODING 104
+#define IDB_EMAIL 106
+#define IDB_MPEG4IP 107
+#define IDB_BROWSE 108
+#define IDI_ID3 110
+#define IDC_CHK_DEFAULTCFG 1000
+#define IDC_CHK_DOWNMATRIX 1001
+#define IDC_CHK_OLDADTS 1002
+#define IDC_CB_SAMPLERATE 1003
+#define IDC_AUDIOCODING 1004
+#define IDC_CB_BITSPERSAMPLE 1004
+#define IDC_EMAIL 1005
+#define IDC_MPEG4IP 1006
+#define IDC_E_BROWSE 1007
+#define IDC_BTN_BROWSE 1008
+#define IDC_RADIO_MPEG4 1009
+#define IDC_RADIO_MPEG2 1010
+#define IDC_RADIO_LOW 1011
+#define IDC_RADIO_MAIN 1012
+#define IDC_RADIO_SSR 1013
+#define IDC_RADIO_LTP 1014
+#define IDC_RADIO_RAW 1015
+#define IDC_RADIO_HE 1016
+#define IDC_BTN_BROWSE2 1016
+#define IDC_BTN_BROWSEIMPORT 1016
+#define IDC_RADIO_ADTS 1017
+#define IDC_CB_BANDWIDTH 1018
+#define IDC_CB_BITRATE 1019
+#define IDC_CHK_ALLOWMIDSIDE 1020
+#define IDC_CHK_USETNS 1021
+#define IDC_CHK_USELFE 1022
+#define IDC_CHK_AUTOCFG 1023
+#define IDC_BTN_ABOUT 1024
+#define IDC_L_ABOUT 1025
+#define IDC_BTN_ARTFILE 1026
+#define IDC_CHK_USETNS2 1027
+#define IDC_CB_EXT 1028
+#define IDC_RADIO_BITRATE 1030
+#define IDC_RADIO_QUALITY 1031
+#define IDC_CB_QUALITY 1032
+#define IDC_E_ARTIST 1034
+#define IDC_CHK_TAG 1035
+#define IDC_E_TITLE 1036
+#define IDC_E_ALBUM 1037
+#define IDC_E_YEAR 1038
+#define IDC_CB_GENRE 1039
+#define IDC_E_WRITER 1040
+#define IDC_E_COMMENT 1041
+#define IDC_E_TRACK 1042
+#define IDC_E_NTRACKS 1043
+#define IDC_E_DISK 1044
+#define IDC_E_NDISKS 1045
+#define IDC_GRP_TAG 1046
+#define IDC_E_COMPILATION 1047
+#define IDC_E_ARTFILE 1048
+#define IDC_BTN_LICENSE 1049
+#define IDC_CHK_COMPILATION 1050
+#define IDC_GRP_DEFAULT 1051
+#define IDC_ID3 1052
+#define IDC_L_BROWSE 1054
+#define IDC_CHK_IMPORTTAG 1055
+#define IDC_E_SOURCEEXT 1056
+#define IDC_E_SOURCEPATH 1057
+
+// Next default values for new objects
+//
+#ifdef APSTUDIO_INVOKED
+#ifndef APSTUDIO_READONLY_SYMBOLS
+#define _APS_NEXT_RESOURCE_VALUE 111
+#define _APS_NEXT_COMMAND_VALUE 40001
+#define _APS_NEXT_CONTROL_VALUE 1057
+#define _APS_NEXT_SYMED_VALUE 101
+#endif
+#endif