mantarimay/Aegisub
1
0
Fork 0
forked from mia/Aegisub
Code Pull requests Activity

Delete the quicktime provider, as it's unmaintained and doesn't work

Browse source 
Originally committed to SVN as r4715.
This commit is contained in:
Thomas Goyne 2010-07-27 03:52:40 +00:00
parent 6407e36c87
commit f0aa85dfbb
13 changed files with 0 additions and 1041 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
aegisub/build/aegisub_vs2008/aegisub_vs2008.vcproj
View file

@ -507,14 +507,6 @@
RelativePath="..\..\src\audio_provider_pcm.h"
>
</File>
<File
RelativePath="..\..\src\audio_provider_quicktime.cpp"
>
</File>
<File
RelativePath="..\..\src\audio_provider_quicktime.h"
>
</File>
<File
RelativePath="..\..\src\audio_provider_ram.cpp"
>
@ -611,14 +603,6 @@
RelativePath="..\..\src\mkv_wrap.h"
>
</File>
<File
RelativePath="..\..\src\quicktime_common.cpp"
>
</File>
<File
RelativePath="..\..\src\quicktime_common.h"
>
</File>
<File
RelativePath="..\..\src\vfw_wrap.cpp"
>
@ -1435,14 +1419,6 @@
RelativePath="..\..\src\video_provider_manager.h"
>
</File>
<File
RelativePath="..\..\src\video_provider_quicktime.cpp"
>
</File>
<File
RelativePath="..\..\src\video_provider_quicktime.h"
>
</File>
<File
RelativePath="..\..\src\video_provider_yuv4mpeg.cpp"
>

12
aegisub/configure.in
View file

@ -777,18 +777,6 @@ AC_SUBST(LIBPOSTPROC_LIBS)
AC_SUBST(LIBPOSTPROC_CFLAGS)
###################
# QuickTime Support
# (mac/windows only)
###################
AM_CONDITIONAL([HAVE_QUICKTIME], [test "$build_darwin" = "yes"])
if test "$build_darwin" = "yes"; then
AC_DEFINE([WITH_QUICKTIME], [1], [QuickTime support.]),
fi
###################
# Subtitle Provider
###################

8
aegisub/src/Makefile.am
View file

@ -95,14 +95,6 @@ aegisub_2_2_LDADD += libaudiovideo_ffmpegsource.a ../libffms/libffmpegsource_aeg
aegisub_2_2_LDFLAGS += @LIBPOSTPROC_LIBS@
endif
if HAVE_QUICKTIME
noinst_LIBRARIES += libaudiovideo_quicktime.a
libaudiovideo_quicktime_a_SOURCES = audio_provider_quicktime.cpp quicktime_common.cpp video_provider_quicktime.cpp
libaudiovideo_quicktime_a_CPPFLAGS = -I/Developer/SDKs/MacOSX10.5.sdk/System/Library/Frameworks/QuickTime.framework/Versions/A/Headers
aegisub_2_2_LDADD += libaudiovideo_quicktime.a
aegisub_2_2_LDFLAGS += -framework QuickTime
endif
noinst_LIBRARIES += libsubtitle_provider.a
libsubtitle_provider_a_SOURCES = subtitles_provider.cpp
libsubtitle_provider_a_CPPFLAGS = @CSRI_CFLAGS@

6
aegisub/src/audio_provider.cpp
View file

@ -53,9 +53,6 @@
#endif
#include "audio_provider_hd.h"
#include "audio_provider_pcm.h"
#ifdef WITH_QUICKTIME
#include "audio_provider_quicktime.h"
#endif
#include "audio_provider_ram.h"
#include "compat.h"
#include "main.h"
@ -318,9 +315,6 @@ void AudioProviderFactoryManager::RegisterProviders() {
#ifdef WITH_FFMPEGSOURCE
RegisterFactory(new FFmpegSourceAudioProviderFactory(),_T("FFmpegSource"));
#endif
#ifdef WITH_QUICKTIME
RegisterFactory(new QuickTimeAudioProviderFactory(), _T("QuickTime"));
#endif
}

205
aegisub/src/audio_provider_quicktime.cpp
View file

@ -1,205 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file audio_provider_quicktime.cpp
/// @brief QuickTime-based audio provider
/// @ingroup audio_input quicktime
///
#include "config.h"
#ifdef WITH_QUICKTIME
#include <libaegisub/log.h>
#include "audio_provider_quicktime.h"
/// @brief DOCME
/// @param filename
///
QuickTimeAudioProvider::QuickTimeAudioProvider(wxString filename) {
movie = NULL;
in_dataref = NULL;
extract_ref = NULL;
inited = false;
qt_err = noErr;
qt_status = noErr;
errmsg = _T("QuickTime audio provider: ");
// try to init quicktime
try {
InitQuickTime();
}
catch (wxString temp) {
errmsg.Append(temp);
throw errmsg;
}
catch (...) {
throw;
}
// try to load audio
try {
LoadAudio(filename);
}
catch (wxString temp) {
errmsg.Append(temp);
throw errmsg;
}
catch (...) {
throw;
}
}
/// @brief DOCME
///
QuickTimeAudioProvider::~QuickTimeAudioProvider() {
Close();
DeInitQuickTime();
}
/// @brief DOCME
///
void QuickTimeAudioProvider::Close() {
if (movie)
DisposeMovie(movie);
movie = NULL;
if (in_dataref)
DisposeHandle(in_dataref);
in_dataref = NULL;
if (inited)
MovieAudioExtractionEnd(extract_ref);
inited = false;
}
/// @brief DOCME
/// @param filename
///
void QuickTimeAudioProvider::LoadAudio(wxString filename) {
OSType in_dataref_type;
wxStringToDataRef(filename, &in_dataref, &in_dataref_type);
// verify that file is openable
if (!CanOpen(in_dataref, in_dataref_type))
throw wxString(_T("QuickTime cannot open file as audio"));
// actually open file
short res_id = 0;
qt_err = NewMovieFromDataRef(&movie, 0, &res_id, in_dataref, in_dataref_type);
QTCheckError(qt_err, wxString(_T("Failed to open file")));
// disable automagic screen rendering just to be safe
qt_err = SetMovieVisualContext(movie, NULL);
QTCheckError(qt_err, wxString(_T("Failed to disable visual context")));
qt_status = MovieAudioExtractionBegin(movie, 0, &extract_ref);
QTCheckError(qt_status, wxString(_T("Failed to initialize audio extraction")));
inited = true;
// and here I thought I knew what "verbose" meant...
AudioStreamBasicDescription asbd;
qt_status = MovieAudioExtractionGetProperty(extract_ref, kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription, sizeof(asbd), &asbd, NULL);
QTCheckError(qt_status, wxString(_T("Failed to retreive audio properties")));
sample_rate = (int)asbd.mSampleRate;
channels = 1; // FIXME: allow more than one channel
bytes_per_sample = 2;
// lazy hack: set the movie time scale to same as the sample rate, to allow for easy seeking
SetMovieTimeScale(movie, (TimeScale)asbd.mSampleRate);
num_samples = GetMovieDuration(movie);
asbd.mFormatFlags = kAudioFormatFlagIsSignedInteger | kAudioFormatFlagIsPacked | kAudioFormatFlagsNativeEndian;
asbd.mBitsPerChannel = sizeof(int16_t) * 8;
asbd.mBytesPerFrame = sizeof(int16_t);
asbd.mBytesPerPacket = asbd.mBytesPerFrame;
asbd.mChannelsPerFrame = 1;
qt_status = MovieAudioExtractionSetProperty(extract_ref, kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription, sizeof(asbd), &asbd);
QTCheckError(qt_status, wxString(_T("Failed to set audio properties")));
AudioChannelLayout ch_layout;
ch_layout.mChannelLayoutTag = kAudioChannelLayoutTag_Mono;
ch_layout.mChannelBitmap = 0;
ch_layout.mNumberChannelDescriptions = 0;
qt_status = MovieAudioExtractionSetProperty(extract_ref, kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout, sizeof(ch_layout), &ch_layout);
QTCheckError(qt_status, wxString(_T("Failed to set channel layout")));
}
/// @brief DOCME
/// @param buf
/// @param start
/// @param count
///
void QuickTimeAudioProvider::GetAudio(void *buf, int64_t start, int64_t count) {
TimeRecord trec;
trec.scale = GetMovieTimeScale(movie);
trec.base = NULL;
trec.value.hi = (int32_t)(start >> 32);
trec.value.lo = (int32_t)((start & 0xFFFFFFFF00000000ULL) >> 32);
qt_status = MovieAudioExtractionSetProperty(extract_ref, kQTPropertyClass_MovieAudioExtraction_Movie,
kQTMovieAudioExtractionMoviePropertyID_CurrentTime, sizeof(TimeRecord), &trec);
QTCheckError(qt_status, wxString(_T("QuickTime audio provider: Failed to seek in file")));
// FIXME: hack something up to actually handle very big counts correctly,
// maybe with multiple buffers?
AudioBufferList dst_buflist;
dst_buflist.mNumberBuffers = 1;
dst_buflist.mBuffers[0].mNumberChannels = 1;
dst_buflist.mBuffers[0].mDataByteSize = count * bytes_per_sample;
dst_buflist.mBuffers[0].mData = buf;
UInt32 flags;
UInt32 decode_count = (UInt32)count;
qt_status = MovieAudioExtractionFillBuffer(extract_ref, &decode_count, &dst_buflist, &flags);
QTCheckError(qt_status, wxString(_T("QuickTime audio provider: Failed to decode audio")));
LOG_W_IF(count != decode_count, "audio/provider/quicktime") << "decoded samplecount " << decode_count << "not same as requested count" << (uint32_t)count);
}
#endif /* WITH_QUICKTIME */

115
aegisub/src/audio_provider_quicktime.h
View file

@ -1,115 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file audio_provider_quicktime.h
/// @see audio_provider_quicktime.cpp
/// @ingroup audio_input quicktime
///
#ifdef WITH_QUICKTIME
#include "quicktime_common.h"
#ifndef AGI_PRE
#include <wx/log.h>
#endif
#include "include/aegisub/audio_provider.h"
/// DOCME
/// @class QuickTimeAudioProvider
/// @brief DOCME
///
/// DOCME
class QuickTimeAudioProvider : public AudioProvider, QuickTimeProvider {
private:
/// DOCME
Movie movie; // input file
/// DOCME
Handle in_dataref; // input file handle
/// DOCME
MovieAudioExtractionRef extract_ref; // extraction session object
/// DOCME
bool inited;
/// DOCME
OSErr qt_err; // quicktime error code
/// DOCME
OSStatus qt_status; // another quicktime error code
/// DOCME
wxString errmsg; // aegisub error messages
void Close();
void LoadAudio(wxString filename);
public:
QuickTimeAudioProvider(wxString filename);
virtual ~QuickTimeAudioProvider();
/// @brief DOCME
/// @return
///
bool AreSamplesNativeEndian() { return true; }
virtual void GetAudio(void *buf, int64_t start, int64_t count);
};
/// DOCME
/// @class QuickTimeAudioProviderFactory
/// @brief DOCME
///
/// DOCME
class QuickTimeAudioProviderFactory : public AudioProviderFactory {
public:
/// @brief DOCME
/// @param file
///
AudioProvider *CreateProvider(wxString file) { return new QuickTimeAudioProvider(file); }
};
#endif /* WITH_QUICKTIME */

6
aegisub/src/config/config_windows0.h
View file

@ -155,9 +155,3 @@
// Display trace-level diagnostic messages during startup
// Only enable for making special builds for end users having trouble with starting Aegisub
//#define WITH_STARTUPLOG
// Enable QuickTime video provider
// Requires QuickTime SDK and (on Windows) a QuickTime7 (or later) installation
//#define WITH_QUICKTIME

166
aegisub/src/quicktime_common.cpp
View file

@ -1,166 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file quicktime_common.cpp
/// @brief Common code between QuickTime-based video and audio providers
/// @ingroup quicktime
///
#include "config.h"
#ifdef WITH_QUICKTIME
#ifndef AGI_PRE
#include <wx/filename.h>
#include <wx/string.h>
#endif
#include "quicktime_common.h"
/// DOCME
int QuickTimeProvider::qt_initcount = 0;
/// DOCME
GWorldPtr QuickTimeProvider::default_gworld = NULL;
/// @brief DOCME
///
void QuickTimeProvider::InitQuickTime() {
OSErr qt_err;
#ifdef WIN32
qt_err = InitializeQTML(0L);
QTCheckError(qt_err, wxString(_T("Failed to initialize QTML (do you have QuickTime installed?)")));
#endif
qt_err = EnterMovies();
QTCheckError(qt_err, wxString(_T("EnterMovies failed")));
// have we been inited before?
if (qt_initcount <= 0) {
// We haven't, allocate an offscreen render target.
// We need to do this before we actually open anything, or quicktime may crash. (heh)
Rect def_box;
def_box.top = 0;
def_box.left = 0;
def_box.bottom = 320; // pick some random dimensions for now;
def_box.right = 240; // we won't actually use this buffer to render anything
QDErr qd_err = NewGWorld(&default_gworld, 32, &def_box, NULL, NULL, keepLocal);
if (qd_err != noErr)
throw wxString(_T("Failed to initialize temporary offscreen drawing buffer"));
SetGWorld(default_gworld, NULL);
}
qt_initcount++;
}
/// @brief DOCME
///
void QuickTimeProvider::DeInitQuickTime() {
#ifdef WIN32
// calls to InitializeQTML() must be balanced with an equal number of calls to TerminateQTML()
TerminateQTML();
#endif
qt_initcount--;
if (qt_initcount <= 0) {
ExitMovies();
DisposeGWorld(default_gworld);
}
}
/// @brief convert a wxstring containing a filename to a QT data reference
/// @param string
/// @param dataref
/// @param dataref_type
///
void QuickTimeProvider::wxStringToDataRef(const wxString &string, Handle *dataref, OSType *dataref_type) {
// convert filename, first to a CFStringRef...
wxString wx_filename = wxFileName(string).GetShortPath();
CFStringRef qt_filename = CFStringCreateWithCString(NULL, wx_filename.utf8_str(), kCFStringEncodingUTF8);
// and then to a data reference
OSErr qt_err = QTNewDataReferenceFromFullPathCFString(qt_filename, kQTNativeDefaultPathStyle, 0,
dataref, dataref_type);
QTCheckError(qt_err, wxString(_T("Failed to convert filename to data reference")));
}
/// @brief check if this error code signifies an error, and if it does, throw an exception
/// @param err
/// @param errmsg
///
void QuickTimeProvider::QTCheckError(OSErr err, wxString errmsg) {
if (err != noErr)
throw errmsg;
/* CheckError(err, errmsg.c_str()); // I wonder if this actually works on Mac, and if so, what it does */
}
/// @brief DOCME
/// @param err
/// @param errmsg
/// @return
///
void QuickTimeProvider::QTCheckError(OSStatus err, wxString errmsg) {
if (err != noErr)
throw errmsg;
}
/// @brief return true if QT considers file openable
/// @param dataref
/// @param dataref_type
///
bool QuickTimeProvider::CanOpen(const Handle& dataref, const OSType dataref_type) {
Boolean can_open;
Boolean prefer_img;
OSErr qt_err = CanQuickTimeOpenDataRef(dataref, dataref_type, NULL, &can_open, &prefer_img, 0);
QTCheckError(qt_err, wxString(_T("Checking if file is openable failed")));
// don't bother trying to open things quicktime considers images
if (can_open && !prefer_img)
return true;
else
return false;
}
#endif /* WITH_QUICKTIME */

102
aegisub/src/quicktime_common.h
View file

@ -1,102 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file quicktime_common.h
/// @see quicktime_common.cpp
/// @ingroup quicktime
///
#include "config.h"
#ifdef WITH_QUICKTIME
#ifndef AGI_PRE
#include <wx/thread.h>
#endif
#include "include/aegisub/aegisub.h"
// QT stuff
#ifdef _MSC_VER
/// DOCME
#define _STDINT_H // avoid conflicts between MSVC's stdint.h and QT's stdint.h
#pragma warning(disable: 4004) // get MSVC to shut up about a macro redefinition in QT's ConditionalMacros.h
#endif
extern "C" {
#ifdef WIN32
#include <QTML.h>
#include <Movies.h>
#include <Files.h>
#include <QDOffscreen.h>
#else
#include <QuickTime/QuickTime.h> // not sure about this path, someone on mac needs to test it
#endif
}
/// DOCME
/// @class QuickTimeProvider
/// @brief DOCME
///
/// DOCME
class QuickTimeProvider {
public:
void InitQuickTime();
void DeInitQuickTime();
void wxStringToDataRef(const wxString &string, Handle *dataref, OSType *dataref_type);
bool CanOpen(const Handle& dataref, const OSType dataref_type);
void QTCheckError(OSErr err, wxString errmsg);
void QTCheckError(OSStatus err, wxString errmsg);
/// DOCME
static int qt_initcount;
/// DOCME
static GWorldPtr default_gworld;
/// @brief DOCME
///
virtual ~QuickTimeProvider() {};
};
#endif /* WITH_QUICKTIME */

4
aegisub/src/setup.cpp
View file

@ -102,10 +102,6 @@
#pragma comment(lib, "ffms2.lib")
#endif
#ifdef WITH_QUICKTIME
#pragma comment(lib, "QTMLClient.lib")
#endif
#ifdef WITH_PORTAUDIO
#pragma comment(lib,"portaudio_x86.lib")
#endif

6
aegisub/src/video_provider_manager.cpp
View file

@ -50,9 +50,6 @@
#include "video_provider_ffmpegsource.h"
#endif
#include "video_provider_manager.h"
#ifdef WITH_QUICKTIME
#include "video_provider_quicktime.h"
#endif
#include "video_provider_yuv4mpeg.h"
@ -119,9 +116,6 @@ void VideoProviderFactoryManager::RegisterProviders() {
#ifdef WITH_FFMPEGSOURCE
RegisterFactory(new FFmpegSourceVideoProviderFactory(),_T("FFmpegSource"));
#endif
#ifdef WITH_QUICKTIME
RegisterFactory(new QuickTimeVideoProviderFactory(),_T("QuickTime"));
#endif
}

256
aegisub/src/video_provider_quicktime.cpp
View file

@ -1,256 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file video_provider_quicktime.cpp
/// @brief QuickTime-based video provider
/// @ingroup video_input quicktime
///
#include "config.h"
#ifdef WITH_QUICKTIME
#ifndef AGI_PRE
#include <wx/msgdlg.h>
#endif
#include "aegisub_endian.h"
#include "video_provider_quicktime.h"
// this function has a different name on win32 because the original name
// conflicts with a windows api function
#ifndef WIN32
/// DOCME
#define MacOffsetRect OffsetRect
#endif
/// @brief DOCME
/// @param filename
///
QuickTimeVideoProvider::QuickTimeVideoProvider(wxString filename) {
in_dataref = NULL;
movie = NULL;
gw = NULL;
w = 0;
h = 0;
cur_fn = -1;
num_frames = 0;
keyframes.clear();
qt_err = noErr;
errmsg = _T("QuickTime video provider: ");
// try to init quicktime
try {
InitQuickTime();
}
catch (wxString temp) {
errmsg.Append(temp);
throw errmsg;
}
catch (...) {
throw;
}
// try loading the file
try {
LoadVideo(filename);
}
catch (wxString temp) {
Close();
errmsg.Append(temp);
throw errmsg;
}
catch (...) {
Close();
throw;
}
}
/// @brief DOCME
///
QuickTimeVideoProvider::~QuickTimeVideoProvider() {
Close();
DeInitQuickTime();
}
/// @brief DOCME
///
void QuickTimeVideoProvider::Close() {
if (movie)
DisposeMovie(movie);
movie = NULL;
if (gw)
DisposeGWorld(gw);
gw = NULL;
if (in_dataref)
DisposeHandle(in_dataref);
in_dataref = NULL;
keyframes.clear();
qt_timestamps.clear();
}
/// @brief DOCME
/// @param _filename
///
void QuickTimeVideoProvider::LoadVideo(const wxString _filename) {
Close();
OSType in_dataref_type;
wxStringToDataRef(_filename, &in_dataref, &in_dataref_type);
// verify that file is openable
if (!CanOpen(in_dataref, in_dataref_type))
throw wxString(_T("QuickTime cannot open file as video"));
// actually open file
short res_id = 0;
qt_err = NewMovieFromDataRef(&movie, newMovieActive, &res_id, in_dataref, in_dataref_type);
QTCheckError(qt_err, wxString(_T("Failed to open file")));
// disable automagic screen rendering
qt_err = SetMovieVisualContext(movie, NULL);
QTCheckError(qt_err, wxString(_T("Failed to disable visual context")));
// set offscreen buffer size to actual movie dimensions
Rect m_box;
GetMovieBox(movie, &m_box);
// make sure its top left corner is at (0,0)
MacOffsetRect(&m_box, -m_box.left, -m_box.top);
SetMovieBox(movie, &m_box);
w = m_box.right;
h = m_box.bottom;
// allocate a new offscreen rendering buffer with the correct dimensions
QDErr qd_err = NewGWorld(&gw, 32, &m_box, NULL, NULL, keepLocal);
QTCheckError(qd_err, wxString(_T("Failed to initialize offscreen drawing buffer")));
// select our new offscreen render target
SetMovieGWorld(movie, gw, NULL);
// get timestamps, keyframes and framecount
std::vector<int> timecodes = IndexFile();
if (timecodes.size() == 0)
throw wxString(_T("QuickTime video provider: failed to index file"));
// ask about vfr override etc
vfr_fps = agi::vfr::Framerate(timecodes);
cur_fn = 0;
}
/// @brief DOCME
/// @return
///
std::vector<int> QuickTimeVideoProvider::IndexFile() {
TimeScale scale = GetMovieTimeScale(movie);
OSType v_type[1];
v_type[0] = VisualMediaCharacteristic;
std::vector<int> timecodes;
std::map<TimeValue,int> timestamp_map; // TODO: just do a binary search instead
int framecount = 1;
TimeValue cur_timeval = 0;
// get the first frame
GetMovieNextInterestingTime(movie, nextTimeMediaSample + nextTimeEdgeOK, 1, v_type, cur_timeval, 0, &cur_timeval, NULL);
// first, find timestamps and count frames
while (cur_timeval >= 0) {
qt_timestamps.push_back(cur_timeval);
timestamp_map.insert(std::pair<TimeValue,int>(cur_timeval, framecount));
timecodes.push_back((cur_timeval * 1000) / scale);
framecount++;
GetMovieNextInterestingTime(movie, nextTimeMediaSample, 1, v_type, cur_timeval, 0, &cur_timeval, NULL);
}
// GetMovieNextInterestingTime() returns -1 when there are no more interesting times,
// so we incremented framecount once too much
num_frames = --framecount;
// next, find keyframes
cur_timeval = 0;
keyframes.push_back(0); // interesting assumption?
while (cur_timeval >= 0) {
GetMovieNextInterestingTime(movie, nextTimeSyncSample, 1, v_type, cur_timeval, 0, &cur_timeval, NULL);
keyframes.push_back(timestamp_map[cur_timeval]);
}
return timecodes;
}
/// @brief DOCME
/// @param n
/// @return
///
const AegiVideoFrame QuickTimeVideoProvider::GetFrame(int n) {
if (n < 0)
n = 0;
if (n >= num_frames)
n = num_frames-1;
cur_fn = n;
// seek
SetMovieTimeValue(movie, qt_timestamps[n]);
qt_err = GetMoviesError();
QTCheckError(qt_err, wxString::Format(_T("QuickTime video provider: failed to seek to TimeValue %d"), qt_timestamps[n]));
// render to offscreen buffer
qt_err = UpdateMovie(movie);
QTCheckError(qt_err, wxString(_T("QuickTime video provider: failed to render frame")));
MoviesTask(movie, 0L);
qt_err = GetMoviesError();
QTCheckError(qt_err, wxString(_T("QuickTime video provider: failed to render frame")));
// set up destination
AegiVideoFrame dst_frame;
dst_frame.format = FORMAT_RGB32;
dst_frame.w = w;
dst_frame.h = h;
dst_frame.invertChannels = true;
dst_frame.flipped = false;
dst_frame.pitch[0] = w * 4; // 4 bytes per sample
dst_frame.Allocate();
// copy data from offscreen buffer
Ptr src_ptr8 = GetPixBaseAddr(GetGWorldPixMap(gw));
uint32_t *src_ptr = reinterpret_cast<uint32_t *>(src_ptr8);
uint32_t *dst_ptr = reinterpret_cast<uint32_t *>(dst_frame.data[0]);
for (int i=0; i<(w*h); i++)
// swap endian if needed; quickdraw always renders big-endian
*dst_ptr++ = Endian::BigToMachine(*src_ptr++); // fun with pointers!
return dst_frame;
}
#endif /* WITH_QUICKTIME */

131
aegisub/src/video_provider_quicktime.h
View file

@ -1,131 +0,0 @@
// Copyright (c) 2009, Karl Blomster
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// * Redistributions of source code must retain the above copyright notice,
// this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
// * Neither the name of the Aegisub Group nor the names of its contributors
// may be used to endorse or promote products derived from this software
// without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
// POSSIBILITY OF SUCH DAMAGE.
//
// Aegisub Project http://www.aegisub.org/
//
// $Id$
/// @file video_provider_quicktime.h
/// @see video_provider_quicktime.cpp
/// @ingroup video_input quicktime
///
#include "quicktime_common.h"
#ifdef WITH_QUICKTIME
#ifndef AGI_PRE
#include <map>
#include <vector>
#include <wx/dynarray.h>
#include <wx/filename.h>
#endif
#include "include/aegisub/video_provider.h"
/// DOCME
/// @class QuickTimeVideoProvider
/// @brief DOCME
///
/// DOCME
class QuickTimeVideoProvider : public VideoProvider, QuickTimeProvider {
/// source object
Movie movie;
/// render buffer
GWorldPtr gw;
/// input data handle
Handle in_dataref;
/// DOCME
/// width/height
int w, h;
/// length of file in frames
int num_frames;
/// current frame number
int cur_fn;
/// vfr framerate
Framerate vfr_fps;
/// list of keyframes
std::vector<int> keyframes;
/// qt timestamps (used for seeking)
std::vector<int> qt_timestamps;
/// quicktime error code
OSErr qt_err;
/// aegisub error message
wxString errmsg;
void LoadVideo(const wxString filename);
std::vector<int> IndexFile();
void Close();
public:
QuickTimeVideoProvider(wxString filename);
~QuickTimeVideoProvider();
const AegiVideoFrame GetFrame(int n);
int GetPosition() const { return cur_fn; }
int GetFrameCount() const { return num_frames; }
int GetWidth() const { return w; }
int GetHeight() const { return h; }
agi::vfr::Framerate GetFPS() const { return vfr_fps; }
std::vector<int> GetKeyFrames() const { return keyframes; };
wxString GetDecoderName() const { return L"QuickTime"; };
bool WantsCaching() const { return true; };
wxString GetWarning() const { return errmsg; }
};
/// DOCME
/// @class QuickTimeVideoProviderFactory
/// @brief DOCME
///
/// DOCME
class QuickTimeVideoProviderFactory : public VideoProviderFactory {
public:
/// @brief DOCME
/// @param video
///
VideoProvider *CreateProvider(wxString video) { return new QuickTimeVideoProvider(video); }
};
#endif /* WITH_QUICKTIME */