Permalink
Switch branches/tags
Nothing to show
Find file Copy path
Fetching contributors…
Cannot retrieve contributors at this time
709 lines (576 sloc) 24.3 KB
/*
* MatroskaExport.c
*
* MatroskaExport.c - QuickTime exporter interface for creating a Matroska file.
*
*
* Copyright (c) 2006 David Conrad
*
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation;
* version 2.1 of the License.
*
* 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this program; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
*
*/
#include <Carbon/Carbon.h>
#include <QuickTime/QuickTime.h>
#include <ebml/c/libebml_t.h>
#include <ebml/IOCallback.h>
#include "DataHandlerCallback.h"
#include "MatroskaExportVersion.h"
#include "MatroskaExport.h"
#include "MkvExportPrivate.h"
#include <iostream>
using namespace std;
#pragma mark- Component Dispatch
// Setup required for ComponentDispatchHelper.c
#define MOVIEEXPORT_BASENAME() MatroskaExport
#define MOVIEEXPORT_GLOBALS() MatroskaExportGlobals storage
#define CALLCOMPONENT_BASENAME() MOVIEEXPORT_BASENAME()
#define CALLCOMPONENT_GLOBALS() MOVIEEXPORT_GLOBALS()
#define QT_BASENAME() MOVIEEXPORT_BASENAME()
#define QT_GLOBALS() MOVIEEXPORT_GLOBALS()
#define COMPONENT_DISPATCH_FILE "MatroskaExportDispatch.h"
#define COMPONENT_UPP_SELECT_ROOT() MovieExport
extern "C"
{
#if __MACH__
#include <CoreServices/Components.k.h>
#include <QuickTime/QuickTimeComponents.k.h>
#include <QuickTime/ImageCompression.k.h> // for ComponentProperty selectors
#include <QuickTime/ComponentDispatchHelper.c>
#else
#include <Components.k.h>
#include <QuickTimeComponents.k.h>
#include <ImageCompression.k.h>
#include <ComponentDispatchHelper.c>
#endif
}
#pragma mark-
// Component Open Request - Required
pascal ComponentResult MatroskaExportOpen(MatroskaExportGlobals store, ComponentInstance self)
{
ComponentDescription cd;
ComponentResult err;
// Allocate memory for our globals, and inform the component manager that we've done so
store = (MatroskaExportGlobals)NewPtrClear(sizeof(MatroskaExportGlobalsRecord));
err = MemError();
if ( err ) goto bail;
store->self = self;
SetComponentInstanceStorage(self, (Handle)store);
// Get the QuickTime Movie export component
// Because we use the QuickTime Movie export component, search for
// the 'MooV' exporter using the following ComponentDescription values
cd.componentType = MovieExportType;
cd.componentSubType = kQTFileTypeMovie;
cd.componentManufacturer = kAppleManufacturer;
cd.componentFlags = canMovieExportFromProcedures | movieExportMustGetSourceMediaType;
cd.componentFlagsMask = cd.componentFlags;
err = OpenAComponent(FindNextComponent(NULL, &cd), &store->quickTimeMovieExporter);
store->outputTracks = new vector<OutputTrack>();
store->sampleBuffer = NewPtr(0);
bail:
return err;
}
// Component Close Request - Required
pascal ComponentResult MatroskaExportClose(MatroskaExportGlobals store, ComponentInstance self)
{
// Make sure to deallocate our storage
if (store) {
if (store->quickTimeMovieExporter)
CloseComponent(store->quickTimeMovieExporter);
if (store->outputTracks)
delete store->outputTracks;
if (store->clusterMetaSeek)
delete store->clusterMetaSeek;
if (store->segment)
delete store->segment;
if (store->metaSeek)
delete store->metaSeek;
if (store->metaSeekPlaceholder)
delete store->metaSeekPlaceholder;
if (store->sampleBuffer)
DisposePtr(store->sampleBuffer);
if (store->cues)
delete store->cues;
if (store->currentCluster) {
store->currentCluster->ReleaseFrames();
delete store->currentCluster;
}
DisposePtr((Ptr)store);
}
return noErr;
}
// Component Version Request - Required
pascal ComponentResult MatroskaExportVersion(MatroskaExportGlobals store)
{
return kMatroskaExportVersion;
}
// GetComponentPropertyInfo
// Component Property Info request - Optional but good practice for QuickTime 7 forward
// Returns information about the properties of a component
pascal ComponentResult MatroskaExportGetComponentPropertyInfo(MatroskaExportGlobals store,
ComponentPropertyClass inPropClass,
ComponentPropertyID inPropID,
ComponentValueType *outPropType,
ByteCount *outPropValueSize,
UInt32 *outPropertyFlags)
{
// we support kComponentPropertyClassPropertyInfo and our own kComponentPropertyClass_Matroska class
ComponentResult err = kQTPropertyNotSupportedErr;
switch (inPropClass) {
case kComponentPropertyClassPropertyInfo:
switch (inPropID) {
case kComponentPropertyInfoList:
if (outPropType) *outPropType = kExportProperties[0].propType;
if (outPropValueSize) *outPropValueSize = kExportProperties[0].propSize;
if (outPropertyFlags) *outPropertyFlags = kExportProperties[0].propFlags;
err = noErr;
break;
default:
break;
}
break;
default:
break;
}
return err;
}
// GetComponentProperty
// Get Component Property request - Optional but good practice for QuickTime 7 forward
// Returns the value of a specific component property
pascal ComponentResult MatroskaExportGetComponentProperty(MatroskaExportGlobals store,
ComponentPropertyClass inPropClass,
ComponentPropertyID inPropID,
ByteCount inPropValueSize,
ComponentValuePtr outPropValueAddress,
ByteCount *outPropValueSizeUsed)
{
ByteCount size = 0;
UInt32 flags = 0;
CFDataRef *outPropCFDataRef;
ComponentResult err = noErr;
// sanity check
if (NULL == outPropValueAddress) return paramErr;
err = QTGetComponentPropertyInfo(store->self, inPropClass, inPropID, NULL, &size, &flags);
if (err) goto bail;
if (size > inPropValueSize) return kQTPropertyBadValueSizeErr;
if (flags & kComponentPropertyFlagCanGetNow) {
switch (inPropID) {
case kComponentPropertyInfoList:
outPropCFDataRef = (CFDataRef *)outPropValueAddress;
*outPropCFDataRef = CFDataCreate(kCFAllocatorDefault,
(UInt8 *)((ComponentPropertyInfo *)kExportProperties),
sizeof(kExportProperties));
if (outPropValueSizeUsed) *outPropValueSizeUsed = size;
break;
default:
break;
}
}
bail:
return err;
}
// SetComponentProperty
// Set Component Property request - Optional but good practice for QuickTime 7 forward
// Sets the value of a specific component property
pascal ComponentResult MatroskaExportSetComponentProperty(MatroskaExportGlobals store,
ComponentPropertyClass inPropClass,
ComponentPropertyID inPropID,
ByteCount inPropValueSize,
ConstComponentValuePtr inPropValueAddress)
{
ByteCount size = 0;
OSType type;
UInt32 flags;
ComponentResult err = noErr;
// validate the caller's params
err = QTGetComponentPropertyInfo(store->self, inPropClass, inPropID, &type, &size, &flags);
if (err) goto bail;
if (size != inPropValueSize) return kQTPropertyBadValueSizeErr;
if (NULL == inPropValueAddress) return paramErr;
if (!(flags & kComponentPropertyFlagCanSetNow)) return kQTPropertyReadOnlyErr;
bail:
return err;
}
#pragma mark-
// MovieExportToFile
// Exports data to a file. The requesting program or Movie Toolbox must create the destination file
// before calling this function. Your component may not destroy any data in the destination file. If you
// cannot add data to the specified file, return an appropriate error. If your component can write data to
// a file, be sure to set the canMovieExportFiles flag in the componentFlags field of your component's
// ComponentDescription structure. Your component must be prepared to perform this function at any time.
// You should not expect that any of your component's configuration functions will be called first.
pascal ComponentResult MatroskaExportToFile(MatroskaExportGlobals store, const FSSpec *theFilePtr,
Movie theMovie, Track onlyThisTrack, TimeValue startTime,
TimeValue duration)
{
AliasHandle alias;
ComponentResult err;
err = QTNewAlias(theFilePtr, &alias, true);
if ( err ) goto bail;
// Implement the export though a file dataRef
err = MovieExportToDataRef(store->self, (Handle)alias, rAliasType, theMovie,
onlyThisTrack, startTime, duration);
DisposeHandle((Handle)alias);
bail:
return err;
}
// MovieExportToDataRef
// Allows an application to request that data be exported to a data reference.
pascal ComponentResult MatroskaExportToDataRef(MatroskaExportGlobals store, Handle dataRef,
OSType dataRefType, Movie theMovie,
Track onlyThisTrack, TimeValue startTime,
TimeValue duration)
{
TimeScale scale;
MovieExportGetPropertyUPP getVideoPropertyProc = NULL;
MovieExportGetDataUPP getVideoDataProc = NULL;
void *videoRefCon;
long trackID;
ComponentResult err;
// Set up the video source
if (true) {
// we only do passthrough for now
store->theMovie = theMovie;
store->onlyThisTrack = onlyThisTrack;
for (int i = 1; i <= GetMovieTrackCount(theMovie); i++) {
OutputTrack outTrack = {0};
outTrack.theTrack = GetMovieIndTrack(theMovie, i);
store->outputTracks->push_back(outTrack);
}
} else {
// This call returns a MovieExportGetPropertyProc (MovieExportGetPropertyUPP)
// and a MovieExportGetDataProc (MovieExportGetDataUPP) callbacks that can be
// passed to MovieExportAddDataSource to create a new data source.
// This function provides a standard way of getting data using this protocol
// out of a movie or track. The returned procedures must be disposed by calling
// MovieExportDisposeGetDataAndPropertiesProcs.
err = MovieExportNewGetDataAndPropertiesProcs(store->quickTimeMovieExporter,
VideoMediaType, &scale, theMovie,
onlyThisTrack, startTime, duration,
&getVideoPropertyProc, &getVideoDataProc,
&videoRefCon);
if (err) goto bail;
// ** Add the video data source **
// Before starting an export operation, all the data sources must be defined
// by calling this function once for each data source
err = MovieExportAddDataSource(store->self, VideoMediaType, scale, &trackID,
getVideoPropertyProc, getVideoDataProc, videoRefCon);
if (err) goto bail;
}
// Perform the export operation
err = MovieExportFromProceduresToDataRef(store->self, dataRef, dataRefType);
bail:
if (getVideoPropertyProc || getVideoDataProc)
// Dispose the the memory associated with the procedures returned by
// MovieExportNewGetDataAndPropertiesProcs
MovieExportDisposeGetDataAndPropertiesProcs(store->quickTimeMovieExporter,
getVideoPropertyProc,
getVideoDataProc,
videoRefCon);
return err;
}
// MovieExportFromProceduresToDataRef
// Exports data provided by MovieExportAddDataSource to a location specified
// by dataRef and dataRefType.
// Movie data export components that support export operations from procedures
// must set the canMovieExportFromProcedures flag in their component flags.
pascal ComponentResult MatroskaExportFromProceduresToDataRef(MatroskaExportGlobals store,
Handle dataRef, OSType dataRefType)
{
long numOfFrames = 0;
TimeValue duration = 0;
DataHandler dataH = NULL;
Boolean progressOpen = false;
ComponentResult err;
if (!dataRef || !dataRefType)
return paramErr;
// Get and open a Data Handler Component that can write to the dataRef
err = OpenAComponent(GetDataHandler(dataRef, dataRefType, kDataHCanWrite), &dataH);
if (err) goto bail;
// Set the DataRef
DataHSetDataRef(dataH, dataRef);
// Create the file
err = DataHCreateFile(dataH, 'TVOD', false);
if ( err ) goto bail;
// Set the file type - this will fail on some platforms, and that's fine
DataHSetMacOSFileType(dataH, 'MkvF');
// Open for write operations
err = DataHOpenForWrite(dataH);
if (err) goto bail;
// Open for write operations
try {
store->ioHandler = new DataHandlerCallback(dataH, MODE_WRITE);
} catch (CRTError crtErr) {
printf("%s\n", crtErr.what());
goto bail;
}
// If we have at least one source track added in the MovieExportAddDataSource call, write some frames
if (store->outputTracks->size() > 0) {
// Since the property proc we call may be a proc returned from MovieExportNewGetDataAndPropertiesProcs,
// configure the QT movie exporter so that it's properties match what we have as our defaults.
// Before we call the proc, we always init the video property to the current default. The proc can either
// be a client proc or one of the procs returned from MovieExportNewGetDataAndPropertiesProcs. In the
// first case, if the proc returns an error for a property selector, the default will be used. If the
// proc is a movie exporter proc, it will always return a property -- namely the property configured for
// the current exporter. If we don't configure the movie exporter, the wrong default would be returned.
err = ConfigureQuickTimeMovieExporter(store);
if (err) goto bail;
// Call the property proc to get our export properties
//GetExportProperty(store);
// If there's a progress proc call it with open request
if (store->progressProc) {
TimeRecord durationTimeRec;
// Get the track duration if it is available
if (store->theMovie) {
store->duration.value.lo = GetMovieDuration(store->theMovie);
store->duration.scale = GetMovieTimeScale(store->theMovie);
InvokeMovieProgressUPP(NULL, movieProgressOpen, progressOpExportMovie, 0,
store->progressRefcon, store->progressProc);
progressOpen = true;
} else {
if (InvokeMovieExportGetPropertyUPP(store->outputTracks->at(0).refCon, 1,
movieExportDuration, &durationTimeRec,
store->outputTracks->at(0).getPropertyProc) == noErr) {
ConvertTimeScale(&durationTimeRec, store->outputTracks->at(0).sourceTimeScale);
duration = durationTimeRec.value.lo;
InvokeMovieProgressUPP(NULL, movieProgressOpen, progressOpExportMovie, 0,
store->progressRefcon, store->progressProc);
progressOpen = true;
store->duration = durationTimeRec;
} else
store->duration.scale = 1;
}
}
WriteHeader(store);
WriteTrackInfo(store);
StartNewCluster(store, 0);
while (true) {
err = WriteFrame(store);
if (err == eofErr)
break;
// Indicate our components progress if required
if (progressOpen) {
Fixed percentDone = FixDiv(store->outputTracks->at(0).currentTime, duration);
if (percentDone > 0x010000)
percentDone = 0x010000;
err = InvokeMovieProgressUPP(NULL, movieProgressUpdatePercent,
progressOpExportMovie, percentDone,
store->progressRefcon, store->progressProc);
if (err) goto bail;
}
}
FinishFile(store);
}
bail:
//if (outputTrack)
// EmptyOutputTrack(outputTrack);
if (store->ioHandler)
delete store->ioHandler;
if (dataH)
CloseComponent(dataH);
// Call the progress proc with a close request if required
if (progressOpen)
InvokeMovieProgressUPP(NULL, movieProgressClose, progressOpExportMovie,
0, store->progressRefcon, store->progressProc);
return err;
}
// MovieExportAddDataSource
// Defines a data source for use with an export operation performed by
// MovieExportFromProceduresToDataRef.
// Before starting an export operation, all the data sources must be defined by
// calling this function once for each data source.
pascal ComponentResult MatroskaExportAddDataSource(MatroskaExportGlobals store,
OSType trackType, TimeScale scale,
long *trackIDPtr,
MovieExportGetPropertyUPP getPropertyProc,
MovieExportGetDataUPP getDataProc, void *refCon)
{
ComponentResult err = noErr;
// We need these or we can't add the data source
if (!scale || !trackType || !getDataProc || !getPropertyProc)
return paramErr;
if (trackType == VideoMediaType || trackType == SoundMediaType) {
OutputTrack outputTrack = {0};
outputTrack.trackID = store->outputTracks->size() + 1;
outputTrack.getPropertyProc = getPropertyProc;
outputTrack.getDataProc = getDataProc;
outputTrack.refCon = refCon;
outputTrack.sourceTimeScale = scale;
store->outputTracks->push_back(outputTrack);
*trackIDPtr = outputTrack.trackID;
}
bail:
return err;
}
// MovieExportValidate
// Determines whether a movie export component can export all the data for
// a specified movie or track.
// This function allows an application to determine if a particular movie or track
// could be exported by the specified movie data export component. The movie or
// track is passed in the theMovie and onlyThisTrack parameters as they are
// passed to MovieExportToFile. Although a movie export component can export one
// or more media types, it may not be able to export all the kinds of data stored
// in those media. Movie data export components that implement this function must
// also set the canMovieExportValidateMovie flag.
pascal ComponentResult MatroskaExportValidate(MatroskaExportGlobals store,
Movie theMovie, Track onlyThisTrack,
Boolean *valid)
{
OSErr err;
// The QT movie export component must be cool with this before we can be
err = MovieExportValidate(store->quickTimeMovieExporter, theMovie, onlyThisTrack, valid);
if (err) goto bail;
if (*valid == true) {
*valid = false;
// check for at least one supported media type
if (onlyThisTrack == NULL) {
for (int i = 0; i < sizeof(kSupportedMediaTypes) / sizeof(OSType); i++) {
if (GetMovieIndTrackType(theMovie, 1, kSupportedMediaTypes[i], movieTrackMediaType)) {
*valid = true;
break;
}
}
} else {
OSType mediaType;
GetMediaHandlerDescription(GetTrackMedia(onlyThisTrack), &mediaType, NULL, NULL);
for (int i = 0; i < sizeof(kSupportedMediaTypes) / sizeof(OSType); i++) {
if (mediaType == kSupportedMediaTypes[i]) {
*valid = true;
break;
}
}
}
}
bail:
return err;
}
#pragma mark -
/* Your component may provide configuration functions. These functions allow
applications to configure your component before the Movie Toolbox calls your
component to start the export process. Note that applications may call these
functions directly. These functions are optional. If your component receives
a request that it does not support, you should return the badComponentSelector
error code. In addition, your component should work properly even if none of
these functions is called.
Applications may retrieve additional data from your component by calling
MovieExportGetAuxiliaryData.
Applications may specify a progress function callback for use by your
component by calling MovieExportSetProgressProc.
Applications may instruct your component to display it's configuration dialog
box by calling MovieExportDoUserDialog.
*/
// MovieExportSetProgressProc
// Assigns a movie progress function to your component. This progress functions
// supports the same interface as Movie Toolbox progress functions. Note that this
// interface not only allows you to report progress to the application, but also
// allows the application to cancel the request.
// See http://developer.apple.com/qa/qa2001/qa1230.html
pascal ComponentResult MatroskaExportSetProgressProc(MatroskaExportGlobals store,
MovieProgressUPP proc, long refcon)
{
store->progressProc = proc;
store->progressRefcon = refcon;
return noErr;
}
#pragma mark-
// MovieExportGetFileNameExtension
// Returns an OSType of the movie export components current file name extention.
pascal ComponentResult MatroskaExportGetFileNameExtension(MatroskaExportGlobals store, OSType *extension)
{
*extension = kMatroskaExportFileNameExtention;
return noErr;
}
// MovieExportGetShortFileTypeString
// Returns a pascal file type string for the exported file.
pascal ComponentResult MatroskaExportGetShortFileTypeString(MatroskaExportGlobals store, Str255 typeString)
{
return GetComponentIndString((Component)store->self, typeString, kMatroskaExportShortFileTypeNamesResID, 1);
}
// MovieExportGetSourceMediaType
// Return either the track type if the movie export component is
// track-specific or 0 if it is track-independent.
pascal ComponentResult MatroskaExportGetSourceMediaType(MatroskaExportGlobals store, OSType *mediaType)
{
#pragma unused(store)
if (!mediaType)
return paramErr;
// we take entire movies; more than one type of track
*mediaType = 0;
return noErr;
}
// ConfigureQuickTimeMovieExporter
// Since the property proc we call may be a proc returned from
// MovieExportNewGetDataAndPropertiesProcs, configure the QuickTime Movie Exporter
// so that it's properties match what we have as our defaults.
static OSErr ConfigureQuickTimeMovieExporter(MatroskaExportGlobals store)
{
SCTemporalSettings temporalSettings;
SCSpatialSettings spatialSettings;
ComponentInstance stdImageCompression = NULL;
QTAtomContainer movieExporterSettings = NULL;
OSErr err;
// Open the Standard Compression component
err = OpenADefaultComponent(StandardCompressionType, StandardCompressionSubType, &stdImageCompression);
if (err) goto bail;
// Set the frame rate
//temporalSettings.frameRate = store->fps;
err = SCSetInfo(stdImageCompression, scTemporalSettingsType, &temporalSettings);
if (err) goto bail;
// Set the depth
//spatialSettings.depth = store->depth;
err = SCSetInfo(stdImageCompression, scSpatialSettingsType, &spatialSettings);
if (err) goto bail;
// Get the settings atom
err = SCGetSettingsAsAtomContainer(stdImageCompression, &movieExporterSettings);
if (err) goto bail;
// Set the compression settings for the QT Movie Exporter
err = MovieExportSetSettingsFromAtomContainer(store->quickTimeMovieExporter, movieExporterSettings);
bail:
if (stdImageCompression)
CloseComponent(stdImageCompression);
if (movieExporterSettings)
DisposeHandle(movieExporterSettings);
return err;
}
#if 0
// GetExportProperty
// This routine calls the MovieExportGetPropertyProc to set up our output properties
static void GetExportProperty(MatroskaExportGlobals store)
{
SCTemporalSettings temporalSettings;
SCSpatialSettings spatialSettings;
Fixed width, height;
OutputTrackPtr outputTrack = &store->outputTracks[0];
// Get the defaults
//outputTrack->fps = store->fps;
//outputTrack->depth = store->depth;
// The getPropertyProc may override some values
if (InvokeMovieExportGetPropertyUPP(outputTrack->refCon, outputTrack->trackID,
scTemporalSettingsType, &temporalSettings,
outputTrack->getPropertyProc) == noErr)
outputTrack->fps = temporalSettings.frameRate;
if (InvokeMovieExportGetPropertyUPP(outputTrack->refCon, outputTrack->trackID,
scSpatialSettingsType, &spatialSettings,
outputTrack->getPropertyProc) == noErr)
outputTrack->depth = spatialSettings.depth;
if (InvokeMovieExportGetPropertyUPP(outputTrack->refCon, outputTrack->trackID,
movieExportWidth, &width,
outputTrack->getPropertyProc) == noErr)
outputTrack->width = width;
if (InvokeMovieExportGetPropertyUPP(outputTrack->refCon, outputTrack->trackID,
movieExportHeight, &height,
outputTrack->getPropertyProc) == noErr)
outputTrack->height = height;
}
#endif