542 lines
15 KiB
C++
542 lines
15 KiB
C++
/**********************************************************************
|
|
|
|
Audacity: A Digital Audio Editor
|
|
|
|
ImportQT.cpp
|
|
|
|
Joshua Haberman
|
|
|
|
On OS X, handles import of MPEG-4 audio including AAC and Apple
|
|
Lossless, import of audio from MPEG-4 video files, and import of
|
|
AIF(F)/AIFC files (AIF(F) might contain content libsndfile can't
|
|
handle). Could be modified to support QuickTime import on Windows.
|
|
|
|
**********************************************************************/
|
|
|
|
#include "../Audacity.h"
|
|
#include "ImportQT.h"
|
|
#include "ImportPlugin.h"
|
|
|
|
#define DESC _("QuickTime files")
|
|
|
|
static const wxChar *exts[] =
|
|
{
|
|
wxT("aif"),
|
|
wxT("aifc"),
|
|
wxT("aiff"),
|
|
wxT("mov"),
|
|
wxT("aac"),
|
|
wxT("m4a"),
|
|
wxT("mp4")
|
|
};
|
|
|
|
#ifndef USE_QUICKTIME
|
|
|
|
void GetQTImportPlugin(ImportPluginList &importPluginList,
|
|
UnusableImportPluginList &unusableImportPluginList)
|
|
{
|
|
unusableImportPluginList.push_back(
|
|
make_movable<UnusableImportPlugin>
|
|
(DESC, wxArrayString(WXSIZEOF(exts), exts))
|
|
);
|
|
}
|
|
|
|
#else /* USE_QUICKTIME */
|
|
|
|
#include <wx/msgdlg.h>
|
|
|
|
// There's a name collision between our Track and QuickTime's...workaround it
|
|
#define Track XTrack
|
|
|
|
#if defined(__WXMAC__)
|
|
// These get used when building under OSX
|
|
#include <Carbon/Carbon.h>
|
|
#include <QuickTime/QuickTime.h>
|
|
|
|
#include <wx/osx/core/private.h>
|
|
#else
|
|
// These get used when building under Windows
|
|
#include <ConditionalMacros.h>
|
|
#include <Movies.h>
|
|
#include <QuickTimeComponents.h>
|
|
#include <Sound.h>
|
|
#include <Folders.h>
|
|
#include <ToolUtils.h>
|
|
#include <Gestalt.h>
|
|
#include <Navigation.h>
|
|
#endif
|
|
|
|
// There's a name collision between our Track and QuickTime's...workaround it
|
|
#undef Track
|
|
|
|
#include "../Internat.h"
|
|
#include "../Tags.h"
|
|
#include "../WaveTrack.h"
|
|
|
|
#define kQTAudioPropertyID_MaxAudioSampleSize 'mssz'
|
|
|
|
class QTImportPlugin final : public ImportPlugin
|
|
{
|
|
public:
|
|
QTImportPlugin()
|
|
: ImportPlugin(wxArrayString(WXSIZEOF(exts), exts)),
|
|
mInitialized(false)
|
|
{
|
|
OSErr err = noErr;
|
|
|
|
#if defined(__WXMSW__)
|
|
err = ::InitializeQTML(0);
|
|
#endif
|
|
|
|
if (err == noErr) {
|
|
err = ::EnterMovies();
|
|
if (err == noErr) {
|
|
mInitialized = true;
|
|
}
|
|
else {
|
|
#if defined(__WXMSW__)
|
|
TerminateQTML();
|
|
#endif
|
|
}
|
|
}
|
|
}
|
|
|
|
~QTImportPlugin()
|
|
{
|
|
if (mInitialized) {
|
|
ExitMovies();
|
|
#if defined(__WXMSW__)
|
|
TerminateQTML();
|
|
#endif
|
|
}
|
|
|
|
mInitialized = false;
|
|
}
|
|
|
|
wxString GetPluginStringID() { return wxT("quicktime"); }
|
|
|
|
wxString GetPluginFormatDescription();
|
|
std::unique_ptr<ImportFileHandle> Open(const wxString & Filename) override;
|
|
|
|
private:
|
|
bool mInitialized;
|
|
};
|
|
|
|
class QTImportFileHandle final : public ImportFileHandle
|
|
{
|
|
public:
|
|
QTImportFileHandle(const wxString & name, Movie movie)
|
|
: ImportFileHandle(name)
|
|
{
|
|
mMovie = movie;
|
|
}
|
|
|
|
virtual ~QTImportFileHandle()
|
|
{
|
|
if (mMovie) {
|
|
DisposeMovie(mMovie);
|
|
mMovie = NULL;
|
|
}
|
|
}
|
|
|
|
wxString GetFileDescription() override;
|
|
ByteCount GetFileUncompressedBytes() override;
|
|
|
|
wxInt32 GetStreamCount() override
|
|
{
|
|
return 1;
|
|
}
|
|
|
|
const wxArrayString &GetStreamInfo() override
|
|
{
|
|
static wxArrayString empty;
|
|
return empty;
|
|
}
|
|
|
|
void SetStreamUsage(wxInt32 StreamID, bool Use) override
|
|
{
|
|
}
|
|
|
|
int Import(TrackFactory *trackFactory,
|
|
TrackHolders &outTracks,
|
|
Tags *tags) override;
|
|
|
|
private:
|
|
void AddMetadata(Tags *tags);
|
|
|
|
Movie mMovie;
|
|
};
|
|
|
|
void GetQTImportPlugin(ImportPluginList &importPluginList,
|
|
UnusableImportPluginList &unusableImportPluginList)
|
|
{
|
|
importPluginList.push_back( make_movable<QTImportPlugin>() );
|
|
}
|
|
|
|
wxString QTImportPlugin::GetPluginFormatDescription()
|
|
{
|
|
return DESC;
|
|
}
|
|
|
|
std::unique_ptr<ImportFileHandle> QTImportPlugin::Open(const wxString & Filename)
|
|
{
|
|
OSErr err;
|
|
FSRef inRef;
|
|
Movie theMovie = NULL;
|
|
Handle dataRef = NULL;
|
|
OSType dataRefType = 0;
|
|
short resID = 0;
|
|
|
|
#if defined(__WXMAC__)
|
|
err = wxMacPathToFSRef(Filename, &inRef);
|
|
#else
|
|
// LLL: This will not work for pathnames with Unicode characters...find
|
|
// another method.
|
|
err = FSPathMakeRef((UInt8 *)OSFILENAME(Filename), &inRef, NULL);
|
|
#endif
|
|
|
|
if (err != noErr) {
|
|
return nullptr;
|
|
}
|
|
|
|
err = QTNewDataReferenceFromFSRef(&inRef, 0, &dataRef, &dataRefType);
|
|
if (err != noErr) {
|
|
return nullptr;
|
|
}
|
|
|
|
// instantiate the movie
|
|
err = NewMovieFromDataRef(&theMovie,
|
|
newMovieActive | newMovieDontAskUnresolvedDataRefs,
|
|
&resID,
|
|
dataRef,
|
|
dataRefType);
|
|
DisposeHandle(dataRef);
|
|
if (err != noErr) {
|
|
return nullptr;
|
|
}
|
|
|
|
return std::make_unique<QTImportFileHandle>(Filename, theMovie);
|
|
}
|
|
|
|
|
|
wxString QTImportFileHandle::GetFileDescription()
|
|
{
|
|
return DESC;
|
|
}
|
|
|
|
auto QTImportFileHandle::GetFileUncompressedBytes() -> ByteCount
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
int QTImportFileHandle::Import(TrackFactory *trackFactory,
|
|
TrackHolders &outTracks,
|
|
Tags *tags)
|
|
{
|
|
outTracks.clear();
|
|
|
|
OSErr err = noErr;
|
|
MovieAudioExtractionRef maer = NULL;
|
|
int updateResult = eProgressSuccess;
|
|
auto totSamples =
|
|
(sampleCount) GetMovieDuration(mMovie); // convert from TimeValue
|
|
decltype(totSamples) numSamples = 0;
|
|
Boolean discrete = true;
|
|
UInt32 quality = kQTAudioRenderQuality_Max;
|
|
AudioStreamBasicDescription desc;
|
|
UInt32 maxSampleSize;
|
|
UInt32 bufsize;
|
|
bool res = false;
|
|
|
|
CreateProgress();
|
|
|
|
do
|
|
{
|
|
err = MovieAudioExtractionBegin(mMovie, 0, &maer);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to start QuickTime extraction"));
|
|
break;
|
|
}
|
|
|
|
err = MovieAudioExtractionSetProperty(maer,
|
|
kQTPropertyClass_MovieAudioExtraction_Audio,
|
|
kQTMovieAudioExtractionAudioPropertyID_RenderQuality,
|
|
sizeof(quality),
|
|
&quality);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to set QuickTime render quality"));
|
|
break;
|
|
}
|
|
|
|
err = MovieAudioExtractionSetProperty(maer,
|
|
kQTPropertyClass_MovieAudioExtraction_Movie,
|
|
kQTMovieAudioExtractionMoviePropertyID_AllChannelsDiscrete,
|
|
sizeof(discrete),
|
|
&discrete);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to set QuickTime discrete channels property"));
|
|
break;
|
|
}
|
|
|
|
err = MovieAudioExtractionGetProperty(maer,
|
|
kQTPropertyClass_MovieAudioExtraction_Audio,
|
|
kQTAudioPropertyID_MaxAudioSampleSize,
|
|
sizeof(maxSampleSize),
|
|
&maxSampleSize,
|
|
NULL);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to get QuickTime sample size property"));
|
|
break;
|
|
}
|
|
|
|
err = MovieAudioExtractionGetProperty(maer,
|
|
kQTPropertyClass_MovieAudioExtraction_Audio,
|
|
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
|
|
sizeof(desc),
|
|
&desc,
|
|
NULL);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to retrieve stream description"));
|
|
break;
|
|
}
|
|
|
|
auto numchan = desc.mChannelsPerFrame;
|
|
bufsize = 5 * desc.mSampleRate;
|
|
|
|
// determine sample format
|
|
sampleFormat format;
|
|
switch (maxSampleSize)
|
|
{
|
|
case 16:
|
|
format = int16Sample;
|
|
break;
|
|
|
|
case 24:
|
|
format = int24Sample;
|
|
break;
|
|
|
|
default:
|
|
format = floatSample;
|
|
break;
|
|
}
|
|
|
|
AudioBufferList *abl = (AudioBufferList *)
|
|
calloc(1, offsetof(AudioBufferList, mBuffers) + (sizeof(AudioBuffer) * numchan));
|
|
abl->mNumberBuffers = numchan;
|
|
|
|
TrackHolders channels{ numchan };
|
|
|
|
int c;
|
|
for (c = 0; c < numchan; c++) {
|
|
abl->mBuffers[c].mNumberChannels = 1;
|
|
abl->mBuffers[c].mDataByteSize = sizeof(float) * bufsize;
|
|
abl->mBuffers[c].mData = malloc(abl->mBuffers[c].mDataByteSize);
|
|
|
|
channels[c] = trackFactory->NewWaveTrack(format);
|
|
channels[c]->SetRate(desc.mSampleRate);
|
|
|
|
if (numchan == 2) {
|
|
if (c == 0) {
|
|
channels[c]->SetChannel(Track::LeftChannel);
|
|
channels[c]->SetLinked(true);
|
|
}
|
|
else if (c == 1) {
|
|
channels[c]->SetChannel(Track::RightChannel);
|
|
}
|
|
}
|
|
}
|
|
|
|
do {
|
|
UInt32 flags = 0;
|
|
UInt32 numFrames = bufsize;
|
|
|
|
err = MovieAudioExtractionFillBuffer(maer,
|
|
&numFrames,
|
|
abl,
|
|
&flags);
|
|
if (err != noErr) {
|
|
wxMessageBox(_("Unable to get fill buffer"));
|
|
break;
|
|
}
|
|
|
|
for (c = 0; c < numchan; c++) {
|
|
channels[c]->Append((char *) abl->mBuffers[c].mData, floatSample, numFrames);
|
|
}
|
|
|
|
numSamples += numFrames;
|
|
|
|
updateResult = mProgress->Update(
|
|
numSamples.as_long_long(),
|
|
totSamples.as_long_long() );
|
|
|
|
if (numFrames == 0 || flags & kQTMovieAudioExtractionComplete) {
|
|
break;
|
|
}
|
|
} while (updateResult == eProgressSuccess);
|
|
|
|
res = (updateResult == eProgressSuccess && err == noErr);
|
|
|
|
if (res) {
|
|
for (const auto &channel: channels) {
|
|
channel->Flush();
|
|
}
|
|
|
|
outTracks.swap(channels);
|
|
}
|
|
|
|
for (c = 0; c < numchan; c++) {
|
|
free(abl->mBuffers[c].mData);
|
|
}
|
|
free(abl);
|
|
|
|
//
|
|
// Extract any metadata
|
|
//
|
|
if (res) {
|
|
AddMetadata(tags);
|
|
}
|
|
} while (false);
|
|
|
|
// done:
|
|
|
|
if (maer) {
|
|
MovieAudioExtractionEnd(maer);
|
|
}
|
|
|
|
return (res ? eProgressSuccess : eProgressFailed);
|
|
}
|
|
|
|
static const struct
|
|
{
|
|
const OSType key;
|
|
const wxChar *name;
|
|
}
|
|
names[] =
|
|
{
|
|
{ kQTMetaDataCommonKeyAuthor, wxT("Author") },
|
|
{ kQTMetaDataCommonKeyComment, TAG_COMMENTS },
|
|
{ kQTMetaDataCommonKeyCopyright, TAG_COPYRIGHT },
|
|
{ kQTMetaDataCommonKeyDirector, wxT("Director") },
|
|
{ kQTMetaDataCommonKeyDisplayName, wxT("Full Name") },
|
|
{ kQTMetaDataCommonKeyInformation, wxT("Information") },
|
|
{ kQTMetaDataCommonKeyKeywords, wxT("Keywords") },
|
|
{ kQTMetaDataCommonKeyProducer, wxT("Producer") },
|
|
{ kQTMetaDataCommonKeyAlbum, TAG_ALBUM },
|
|
{ kQTMetaDataCommonKeyArtist, TAG_ARTIST },
|
|
{ kQTMetaDataCommonKeyChapterName, wxT("Chapter") },
|
|
{ kQTMetaDataCommonKeyComposer, wxT("Composer") },
|
|
{ kQTMetaDataCommonKeyDescription, wxT("Description") },
|
|
{ kQTMetaDataCommonKeyGenre, TAG_GENRE },
|
|
{ kQTMetaDataCommonKeyOriginalFormat, wxT("Original Format") },
|
|
{ kQTMetaDataCommonKeyOriginalSource, wxT("Original Source") },
|
|
{ kQTMetaDataCommonKeyPerformers, wxT("Performers") },
|
|
{ kQTMetaDataCommonKeySoftware, TAG_SOFTWARE },
|
|
{ kQTMetaDataCommonKeyWriter, wxT("Writer") },
|
|
};
|
|
|
|
void QTImportFileHandle::AddMetadata(Tags *tags)
|
|
{
|
|
QTMetaDataRef metaDataRef = NULL;
|
|
OSErr err;
|
|
|
|
err = QTCopyMovieMetaData(mMovie, &metaDataRef);
|
|
if (err != noErr) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < WXSIZEOF(names); i++) {
|
|
QTMetaDataItem item = kQTMetaDataItemUninitialized;
|
|
// OSType key = names[i].key;
|
|
|
|
err = QTMetaDataGetNextItem(metaDataRef,
|
|
kQTMetaDataStorageFormatWildcard,
|
|
kQTMetaDataItemUninitialized,
|
|
kQTMetaDataKeyFormatCommon,
|
|
(const UInt8 *) &names[i].key,
|
|
sizeof(names[i].key),
|
|
&item);
|
|
if (err != noErr) {
|
|
continue;
|
|
}
|
|
|
|
if (item == kQTMetaDataItemUninitialized) {
|
|
continue;
|
|
}
|
|
|
|
QTPropertyValuePtr outValPtr = nil;
|
|
QTPropertyValueType outPropType;
|
|
::ByteCount outPropValueSize;
|
|
::ByteCount outPropValueSizeUsed = 0;
|
|
UInt32 outPropFlags;
|
|
UInt32 dataType;
|
|
|
|
// Get data type
|
|
err = QTMetaDataGetItemProperty(metaDataRef,
|
|
item,
|
|
kPropertyClass_MetaDataItem,
|
|
kQTMetaDataItemPropertyID_DataType,
|
|
sizeof(dataType),
|
|
&dataType,
|
|
&outPropValueSizeUsed);
|
|
if (err != noErr) {
|
|
continue;
|
|
}
|
|
|
|
// Get the data length
|
|
err = QTMetaDataGetItemPropertyInfo(metaDataRef,
|
|
item,
|
|
kPropertyClass_MetaDataItem,
|
|
kQTMetaDataItemPropertyID_Value,
|
|
&outPropType,
|
|
&outPropValueSize,
|
|
&outPropFlags );
|
|
if (err != noErr) {
|
|
continue;
|
|
}
|
|
|
|
// Alloc memory for it
|
|
outValPtr = malloc(outPropValueSize);
|
|
|
|
// Retrieve the data
|
|
err = QTMetaDataGetItemProperty(metaDataRef,
|
|
item,
|
|
kPropertyClass_MetaDataItem,
|
|
kQTMetaDataItemPropertyID_Value,
|
|
outPropValueSize,
|
|
outValPtr,
|
|
&outPropValueSizeUsed);
|
|
if (err != noErr) {
|
|
free(outValPtr);
|
|
continue;
|
|
}
|
|
|
|
wxString v = wxT("");
|
|
|
|
switch (dataType)
|
|
{
|
|
case kQTMetaDataTypeUTF8:
|
|
v = wxString((char *)outValPtr, wxConvUTF8);
|
|
break;
|
|
case kQTMetaDataTypeUTF16BE:
|
|
{
|
|
wxMBConvUTF16BE conv;
|
|
v = wxString((char *)outValPtr, conv);
|
|
}
|
|
break;
|
|
}
|
|
|
|
if (!v.IsEmpty()) {
|
|
tags->SetTag(names[i].name, v);
|
|
}
|
|
|
|
free(outValPtr);
|
|
}
|
|
|
|
// we are done so release our metadata object
|
|
QTMetaDataRelease(metaDataRef);
|
|
|
|
return;
|
|
}
|
|
|
|
#endif
|