/*
Given a reference to the media that contains the sample data for a track,
calculate the static frame rate.
*/
OSErr MediaGetStaticFrameRate(Media inMovieMedia, double *outFPS)
{
*outFPS = 0;
/* get the number of samples in the media */
long sampleCount = GetMediaSampleCount(inMovieMedia);
OSErr err = GetMoviesError();
if (sampleCount && err == noErr)
{
/* find the media duration */
//Quicktime 7.0 code
//TimeValue64 duration = GetMediaDisplayDuration(inMovieMedia);
TimeValue64 duration = GetMediaDuration(inMovieMedia);
err = GetMoviesError();
if (err == noErr)
{
/* get the media time scale */
TimeValue64 timeScale = GetMediaTimeScale(inMovieMedia);
err = GetMoviesError();
if (err == noErr)
{
/* calculate the frame rate:
frame rate = (sample count * media time scale) / media duration
*/
*outFPS = (double)sampleCount * (double)timeScale / (double)duration;
}
}
}
return err;
}
/*----------------------------------------------------------------------
| AP4_Track::GetSampleIndexForTimeStampMs
+---------------------------------------------------------------------*/
AP4_Result
AP4_Track::GetSampleIndexForTimeStampMs(AP4_UI32 ts_ms, AP4_Ordinal& index)
{
// convert the ts in the timescale of the track's media
AP4_UI64 ts = AP4_ConvertTime(ts_ms, 1000, GetMediaTimeScale());
return m_SampleTable->GetSampleIndexForTimeStamp(ts, index);
}
TLevelReader3gp::TLevelReader3gp(const TFilePath &path)
: TLevelReader(path), m_IOError(QTNoError), m_track(0), m_movie(0), m_depth(0)
// ,m_timeScale(0)
{
FSSpec fspec;
QDErr err;
Boolean dataRefWasChanged;
if (QuickTimeStuff::instance()->getStatus() != noErr) {
m_IOError = QTNotInstalled;
return;
}
const char *pStr = toString(m_path.getWideString()).c_str();
FSMakeFSSpec(0, 0, (const unsigned char *)pStr, &fspec);
getFSSpecFromPosixPath(pStr, &fspec, false);
pStr = 0;
if ((err = OpenMovieFile(&fspec, &m_refNum, fsRdPerm))) {
m_IOError = QTUnableToOpenFile;
return;
}
m_resId = 0;
Str255 name;
err = NewMovieFromFile(&m_movie, m_refNum, &m_resId,
name, fsRdPerm, &dataRefWasChanged);
int numTracks = GetMovieTrackCount(m_movie);
assert(numTracks == 1 || numTracks == 2);
m_track = GetMovieIndTrackType(m_movie, 1, VideoMediaType, movieTrackMediaType);
//m_track=GetMovieTrack(m_movie,numTracks);
ImageDescriptionHandle imageH;
imageH = (ImageDescriptionHandle)NewHandleClear(sizeof(ImageDescription));
TINT32 index = 1;
Media theMedia = GetTrackMedia(m_track);
GetMediaSampleDescription(theMedia, index, (SampleDescriptionHandle)imageH);
ImageDescriptionPtr imagePtr = *imageH;
m_lx = imagePtr->width;
m_ly = imagePtr->height;
m_depth = imagePtr->depth;
m_info = new TImageInfo();
m_info->m_lx = m_lx;
m_info->m_ly = m_ly;
Tiio::MovWriterProperties *prop = new Tiio::MovWriterProperties();
m_info->m_properties = prop;
DisposeHandle((Handle)imageH);
m_info->m_frameRate = GetMediaTimeScale(theMedia);
}
/*----------------------------------------------------------------------
| AP4_Track::Clone
+---------------------------------------------------------------------*/
AP4_Track*
AP4_Track::Clone(AP4_Result* result)
{
AP4_SyntheticSampleTable* sample_table = new AP4_SyntheticSampleTable();
// default return value
if (result) *result = AP4_SUCCESS;
// add clones of the sample descriptions to the new sample table
for (unsigned int i=0; ;i++) {
AP4_SampleDescription* sample_description = GetSampleDescription(i);
if (sample_description == NULL) break;
sample_table->AddSampleDescription(sample_description->Clone());
}
AP4_Sample sample;
AP4_Ordinal index = 0;
while (AP4_SUCCEEDED(GetSample(index, sample))) {
AP4_ByteStream* data_stream;
data_stream = sample.GetDataStream();
sample_table->AddSample(*data_stream,
sample.GetOffset(),
sample.GetSize(),
sample.GetDuration(),
sample.GetDescriptionIndex(),
sample.GetDts(),
sample.GetCtsDelta(),
sample.IsSync());
AP4_RELEASE(data_stream); // release our ref, the table has kept its own ref.
index++;
}
// create the cloned track
AP4_Track* clone = new AP4_Track(GetType(),
sample_table,
GetId(),
GetMovieTimeScale(),
GetDuration(),
GetMediaTimeScale(),
GetMediaDuration(),
GetTrackLanguage(),
GetWidth(),
GetHeight());
return clone;
}
int convertToMP4PathThrough(CFStringRef inFile, CFStringRef outFile)
{
OSStatus error;
MovieExportComponent movieExporter = NULL;
Handle inDataRef=0, outDataRef=0;
OSType inDataRefType, outDataRefType;
short inResID = 0;
Movie theMovie=0;
int ret = -1;
error = OpenADefaultComponent(MovieExportType, kQTFileTypeMP4, &movieExporter);
if(error) {
fprintf(stderr,"OpenADefaultComponent error: cannot find the QuickTime conponent\n");
goto last;
}
error = QTNewDataReferenceFromFullPathCFString(inFile, kQTNativeDefaultPathStyle, 0, &inDataRef, &inDataRefType);
if(error) {
fprintf(stderr,"QTNewDataReferenceFromFullPathCFString error: input file path is invalid\n");
goto last;
}
error = QTNewDataReferenceFromFullPathCFString(outFile, kQTNativeDefaultPathStyle, 0, &outDataRef, &outDataRefType);
if(error) {
fprintf(stderr,"QTNewDataReferenceFromFullPathCFString error: output file path is invalid\n");
goto last;
}
error = NewMovieFromDataRef(&theMovie, newMovieActive, &inResID, inDataRef, inDataRefType);
if(error) {
fprintf(stderr,"NewMovieFromDataRef error: cannot open the input file\n");
goto last;
}
Track theTrack = getSoundTrack(theMovie);
Media theMedia = GetTrackMedia(theTrack);
DeleteTrackSegment(theTrack, 0, GetTrackDuration(theTrack));
SetMovieTimeScale(theMovie, GetMediaTimeScale(theMedia));
InsertMediaIntoTrack(theTrack, 0, 0, GetMediaDuration(theMedia), fixed1);
Boolean useHighResolutionAudio = true;
QTSetComponentProperty(
movieExporter,
kQTPropertyClass_MovieExporter,
kQTMovieExporterPropertyID_EnableHighResolutionAudioFeatures,
sizeof(Boolean),
&useHighResolutionAudio
);
UInt32 ftyp = 'mp42';
QTSetComponentProperty(
movieExporter,
kQTPropertyClass_MovieExporter,
'ftyp',
4,
&ftyp
);
QTAtomContainer ac;
MovieExportGetSettingsAsAtomContainer(movieExporter, &ac);
QTAtom ensoAtom = QTFindChildByID(ac, kParentAtomIsContainer, kQTSettingsMovieExportEnableSound, 1, NULL);
if(ensoAtom) {
long size, *data;
QTGetAtomDataPtr(ac,ensoAtom,&size,(Ptr *)&data);
data[0] = EndianS32_NtoB('past');
QTSetAtomData(ac, ensoAtom, size, data);
MovieExportSetSettingsFromAtomContainer(movieExporter, ac);
}
DisposeHandle(ac);
/*Boolean cancelled;
error = MovieExportDoUserDialog(movieExporter, theMovie, NULL, 0, GetMovieDuration(theMovie), &cancelled);
if(cancelled) goto last;
if(error) {
printf("MovieExportDoUserDialog error\n");
goto last;
}*/
error = ConvertMovieToDataRef(theMovie, 0, outDataRef, outDataRefType, kQTFileTypeMP4, FOUR_CHAR_CODE('TVOD'), createMovieFileDeleteCurFile|createMovieFileDontCreateResFile, movieExporter);
if(error) {
fprintf(stderr,"ConvertMovieToDataRef error: cannot translate .mov into .m4a (%d)\n",error);
goto last;
}
ret = 0;
last:
if(movieExporter) CloseComponent(movieExporter);
if(theMovie) DisposeMovie(theMovie);
if(inDataRef) DisposeHandle(inDataRef);
if(outDataRef) DisposeHandle(outDataRef);
return ret;
}
/*
call-seq: time_scale() -> scale_int
Returns the time scale of the track. Usually only needed when working
with raw_duration.
*/
static VALUE track_time_scale(VALUE obj)
{
return INT2NUM(GetMediaTimeScale(TRACK_MEDIA(obj)));
}
/*
call-seq: offset() -> seconds
Returns the offset of the track from the beginning of the movie (in seconds).
*/
static VALUE track_get_offset(VALUE obj)
{
return rb_float_new((double)GetTrackOffset(TRACK(obj))/GetMediaTimeScale(TRACK_MEDIA(obj)));
}
static HRESULT QT_Process_Video_Track(QTSplitter* filter, Track trk)
{
AM_MEDIA_TYPE amt;
VIDEOINFOHEADER * pvi;
PIN_INFO piOutput;
HRESULT hr = S_OK;
OSErr err;
static const WCHAR szwVideoOut[] = {'V','i','d','e','o',0};
CFMutableDictionaryRef pixelBufferOptions = NULL;
CFMutableDictionaryRef visualContextOptions = NULL;
CFNumberRef n = NULL;
int t;
DWORD outputWidth, outputHeight, outputDepth;
Fixed trackWidth, trackHeight;
Media videoMedia;
long sampleCount;
TimeValue64 duration;
TimeScale timeScale;
ZeroMemory(&amt, sizeof(amt));
amt.formattype = FORMAT_VideoInfo;
amt.majortype = MEDIATYPE_Video;
amt.subtype = MEDIASUBTYPE_RGB24;
GetTrackDimensions(trk, &trackWidth, &trackHeight);
outputDepth = 3;
outputWidth = Fix2Long(trackWidth);
outputHeight = Fix2Long(trackHeight);
TRACE("Width %i Height %i\n",outputWidth, outputHeight);
amt.cbFormat = sizeof(VIDEOINFOHEADER);
amt.pbFormat = CoTaskMemAlloc(amt.cbFormat);
ZeroMemory(amt.pbFormat, amt.cbFormat);
pvi = (VIDEOINFOHEADER *)amt.pbFormat;
pvi->bmiHeader.biSize = sizeof (BITMAPINFOHEADER);
pvi->bmiHeader.biWidth = outputWidth;
pvi->bmiHeader.biHeight = outputHeight;
pvi->bmiHeader.biPlanes = 1;
pvi->bmiHeader.biBitCount = 24;
pvi->bmiHeader.biCompression = BI_RGB;
pvi->bmiHeader.biSizeImage = outputWidth * outputHeight * outputDepth;
filter->outputSize = pvi->bmiHeader.biSizeImage;
amt.lSampleSize = 0;
pixelBufferOptions = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
t = k32ARGBPixelFormat;
n = CFNumberCreate(NULL, kCFNumberIntType, &t);
CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferPixelFormatTypeKey, n);
CFRelease(n);
n = CFNumberCreate(NULL, kCFNumberIntType, &outputWidth);
CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferWidthKey, n);
CFRelease(n);
n = CFNumberCreate(NULL, kCFNumberIntType, &outputHeight);
CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferHeightKey, n);
CFRelease(n);
t = 16;
n = CFNumberCreate(NULL, kCFNumberIntType, &t);
CFDictionaryAddValue(pixelBufferOptions, kCVPixelBufferBytesPerRowAlignmentKey, n);
CFRelease(n);
visualContextOptions = CFDictionaryCreateMutable(NULL, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
CFDictionarySetValue(visualContextOptions, kQTVisualContextPixelBufferAttributesKey, pixelBufferOptions);
err = QTPixelBufferContextCreate(NULL, visualContextOptions,&filter->vContext);
CFRelease(pixelBufferOptions);
CFRelease(visualContextOptions);
if (err != noErr)
{
ERR("Failed to create Visual Context\n");
return E_FAIL;
}
err = SetMovieVisualContext(filter->pQTMovie, filter->vContext);
if (err != noErr)
{
ERR("Failed to set Visual Context\n");
return E_FAIL;
}
videoMedia = GetTrackMedia(trk);
sampleCount = GetMediaSampleCount(videoMedia);
timeScale = GetMediaTimeScale(videoMedia);
duration = GetMediaDisplayDuration(videoMedia);
pvi->AvgTimePerFrame = (100000.0 * sampleCount * timeScale) / duration;
piOutput.dir = PINDIR_OUTPUT;
piOutput.pFilter = &filter->filter.IBaseFilter_iface;
lstrcpyW(piOutput.achName,szwVideoOut);
hr = QT_AddPin(filter, &piOutput, &amt, TRUE);
if (FAILED(hr))
ERR("Failed to add Video Track\n");
else
TRACE("Video Pin %p\n",filter->pVideo_Pin);
return hr;
}
QTAudioReader (InputStream* const input_, const int trackNum_)
: AudioFormatReader (input_, TRANS (quickTimeFormatName)),
ok (false),
movie (0),
trackNum (trackNum_),
lastSampleRead (0),
lastThreadId (0),
extractor (0),
dataHandle (0)
{
JUCE_AUTORELEASEPOOL
bufferList.calloc (256, 1);
#if JUCE_WINDOWS
if (InitializeQTML (0) != noErr)
return;
#endif
if (EnterMovies() != noErr)
return;
bool opened = juce_OpenQuickTimeMovieFromStream (input_, movie, dataHandle);
if (! opened)
return;
{
const int numTracks = GetMovieTrackCount (movie);
int trackCount = 0;
for (int i = 1; i <= numTracks; ++i)
{
track = GetMovieIndTrack (movie, i);
media = GetTrackMedia (track);
OSType mediaType;
GetMediaHandlerDescription (media, &mediaType, 0, 0);
if (mediaType == SoundMediaType
&& trackCount++ == trackNum_)
{
ok = true;
break;
}
}
}
if (! ok)
return;
ok = false;
lengthInSamples = GetMediaDecodeDuration (media);
usesFloatingPointData = false;
samplesPerFrame = (int) (GetMediaDecodeDuration (media) / GetMediaSampleCount (media));
trackUnitsPerFrame = GetMovieTimeScale (movie) * samplesPerFrame
/ GetMediaTimeScale (media);
OSStatus err = MovieAudioExtractionBegin (movie, 0, &extractor);
unsigned long output_layout_size;
err = MovieAudioExtractionGetPropertyInfo (extractor,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
0, &output_layout_size, 0);
if (err != noErr)
return;
HeapBlock <AudioChannelLayout> qt_audio_channel_layout;
qt_audio_channel_layout.calloc (output_layout_size, 1);
err = MovieAudioExtractionGetProperty (extractor,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
output_layout_size, qt_audio_channel_layout, 0);
qt_audio_channel_layout[0].mChannelLayoutTag = kAudioChannelLayoutTag_Stereo;
err = MovieAudioExtractionSetProperty (extractor,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioChannelLayout,
output_layout_size,
qt_audio_channel_layout);
err = MovieAudioExtractionGetProperty (extractor,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
sizeof (inputStreamDesc),
&inputStreamDesc, 0);
if (err != noErr)
return;
inputStreamDesc.mFormatFlags = kAudioFormatFlagIsSignedInteger
| kAudioFormatFlagIsPacked
| kAudioFormatFlagsNativeEndian;
inputStreamDesc.mBitsPerChannel = sizeof (SInt16) * 8;
inputStreamDesc.mChannelsPerFrame = jmin ((UInt32) 2, inputStreamDesc.mChannelsPerFrame);
inputStreamDesc.mBytesPerFrame = sizeof (SInt16) * inputStreamDesc.mChannelsPerFrame;
inputStreamDesc.mBytesPerPacket = inputStreamDesc.mBytesPerFrame;
err = MovieAudioExtractionSetProperty (extractor,
kQTPropertyClass_MovieAudioExtraction_Audio,
kQTMovieAudioExtractionAudioPropertyID_AudioStreamBasicDescription,
sizeof (inputStreamDesc),
&inputStreamDesc);
if (err != noErr)
return;
Boolean allChannelsDiscrete = false;
err = MovieAudioExtractionSetProperty (extractor,
kQTPropertyClass_MovieAudioExtraction_Movie,
kQTMovieAudioExtractionMoviePropertyID_AllChannelsDiscrete,
sizeof (allChannelsDiscrete),
&allChannelsDiscrete);
if (err != noErr)
return;
bufferList->mNumberBuffers = 1;
bufferList->mBuffers[0].mNumberChannels = inputStreamDesc.mChannelsPerFrame;
bufferList->mBuffers[0].mDataByteSize = jmax ((UInt32) 4096, (UInt32) (samplesPerFrame * inputStreamDesc.mBytesPerFrame) + 16);
dataBuffer.malloc (bufferList->mBuffers[0].mDataByteSize);
bufferList->mBuffers[0].mData = dataBuffer;
sampleRate = inputStreamDesc.mSampleRate;
bitsPerSample = 16;
numChannels = inputStreamDesc.mChannelsPerFrame;
detachThread();
ok = true;
}
ComponentResult process_stream_page__speex(OggImportGlobals *globals, StreamInfo *si, ogg_page *opg)
{
ComponentResult ret = noErr;
int ovret = 0;
Boolean loop = true;
Boolean movie_changed = false;
TimeValue movieTS = GetMovieTimeScale(globals->theMovie);
TimeValue mediaTS = 0;
TimeValue mediaTS_fl = 0.0;
ogg_packet op;
switch(si->si_speex.state) {
case kSStateReadingComments:
case kSStateReadingAdditionalHeaders:
ogg_stream_pagein(&si->os, opg);
break;
default:
break;
}
do {
switch(si->si_speex.state) {
case kSStateReadingComments:
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeSpeexComments) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
ret = CreateTrackAndMedia(globals, si, opg);
if (ret != noErr) {
dbg_printf("??? -- CreateTrackAndMedia failed?: %ld\n", (long)ret);
}
unpack_vorbis_comments(&si->si_speex.vc, op.packet, op.bytes);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_speex.vc);
//NotifyMovieChanged(globals);
si->si_speex.state = kSStateReadingAdditionalHeaders;
}
break;
case kSStateReadingAdditionalHeaders:
if (si->si_speex.skipped_headers >= si->si_speex.header.extra_headers) {
unsigned long endAtom[2] = { EndianU32_NtoB(sizeof(endAtom)), EndianU32_NtoB(kAudioTerminatorAtomType) };
ret = PtrAndHand(endAtom, si->soundDescExtension, sizeof(endAtom));
if (ret == noErr) {
ret = AddSoundDescriptionExtension((SoundDescriptionHandle) si->sampleDesc,
si->soundDescExtension, siDecompressionParams);
//dbg_printf("??? -- Adding extension: %ld\n", ret);
} else {
//dbg_printf("??? -- Hmm, something went wrong: %ld\n", ret);
}
si->insertTime = 0;
si->streamOffset = globals->currentGroupOffset;
mediaTS = GetMediaTimeScale(si->theMedia);
mediaTS_fl = (Float64) mediaTS;
si->streamOffsetSamples = (TimeValue) (mediaTS_fl * globals->currentGroupOffsetSubSecond) -
((globals->currentGroupOffset % movieTS) * mediaTS / movieTS);
dbg_printf("---/ / streamOffset: [%ld, %ld], %lg\n", si->streamOffset, si->streamOffsetSamples, globals->currentGroupOffsetSubSecond);
si->incompleteCompensation = 0;
si->si_speex.state = kSStateReadingFirstPacket;
loop = false; // ??!
break;
}
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
// not much here so far, basically just skip the extra header packet
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeSpeexExtraHeader) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
si->si_speex.skipped_headers += 1;
}
break;
case kSStateReadingFirstPacket:
if (ogg_page_pageno(opg) > 2) {
si->lastGranulePos = ogg_page_granulepos(opg);
dbg_printf("----==< skipping: %llx, %lx\n", si->lastGranulePos, ogg_page_pageno(opg));
loop = false;
if (si->lastGranulePos < 0)
si->lastGranulePos = 0;
}
si->si_speex.state = kSStateReadingPackets;
break;
case kVStateReadingPackets:
{
ogg_int64_t pos = ogg_page_granulepos(opg);
int len = opg->header_len + opg->body_len;
TimeValue duration = pos - si->lastGranulePos;
short smp_flags = 0;
if (ogg_page_continued(opg) || si->incompleteCompensation != 0)
smp_flags |= mediaSampleNotSync;
if (duration <= 0) {
duration = INCOMPLETE_PAGE_DURATION;
si->incompleteCompensation -= INCOMPLETE_PAGE_DURATION;
} else if (si->incompleteCompensation != 0) {
duration += si->incompleteCompensation;
si->incompleteCompensation = 0;
if (duration <= 0) {
ret = badFileFormat;
loop = false;
break;
}
}
if (si->insertTime == 0 && si->streamOffsetSamples > 0) {
dbg_printf(" - :++: increasing duration (%ld) by sampleOffset: %ld\n", duration, si->streamOffsetSamples);
duration += si->streamOffsetSamples;
}
ret = _store_sample_reference(si, &globals->dataOffset, len, duration, smp_flags);
if (ret != noErr) {
loop = false;
break;
}
if (!globals->usingIdle) {
if (si->sample_refs_count >= kSSRefsInitial)
ret = _commit_srefs(globals, si, &movie_changed);
}
if (pos != -1)
si->lastGranulePos = pos;
}
loop = false;
break;
default:
loop = false;
}
} while(loop);
if (movie_changed)
NotifyMovieChanged(globals, false);
return ret;
};
OSErr QTDR_CreateReferenceCopy (Movie theSrcMovie, FSSpecPtr theDstMovieFile, FSSpecPtr theDstMediaFile)
{
Track mySrcTrack = NULL;
Media mySrcMedia = NULL;
Movie myDstMovie = NULL;
Track myDstTrack = NULL;
Media myDstMedia = NULL;
Handle myMediaRef = NULL; // data reference for the media file
#if !USE_ADDEMPTYTRACKTOMOVIE
Fixed myWidth, myHeight;
OSType myType;
#endif
long myFlags = createMovieFileDeleteCurFile | createMovieFileDontCreateResFile;
short myResRefNum = 0;
short myResID = movieInDataForkResID;
OSErr myErr = paramErr;
// get the first video track and media in the source movie
mySrcTrack = GetMovieIndTrackType(theSrcMovie, 1, VideoMediaType, movieTrackMediaType);
if (mySrcTrack == NULL)
goto bail;
mySrcMedia = GetTrackMedia(mySrcTrack);
if (mySrcMedia == NULL)
goto bail;
// create a file data reference for the new media file
myMediaRef = QTDR_MakeFileDataRef(theDstMediaFile);
if (myMediaRef == NULL)
goto bail;
// create a file for the destination movie data
myErr = FSpCreate(theDstMediaFile, sigMoviePlayer, MovieFileType, 0);
if (myErr != noErr)
goto bail;
// create a file for the destination movie atom and create an empty movie
myErr = CreateMovieFile(theDstMovieFile, sigMoviePlayer, smCurrentScript, myFlags, &myResRefNum, &myDstMovie);
if (myErr != noErr)
goto bail;
// assign the default progress proc to the destination movie
SetMovieProgressProc(myDstMovie, (MovieProgressUPP)-1, 0);
#if USE_ADDEMPTYTRACKTOMOVIE
myErr = AddEmptyTrackToMovie(mySrcTrack, myDstMovie, myMediaRef, rAliasType, &myDstTrack);
if (myErr != noErr)
goto bail;
myDstMedia = GetTrackMedia(myDstTrack);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
#else
// get some information about the source track and media
GetTrackDimensions(mySrcTrack, &myWidth, &myHeight);
GetMediaHandlerDescription(mySrcMedia, &myType, 0, 0);
// create the destination movie track and media
myDstTrack = NewMovieTrack(myDstMovie, myWidth, myHeight, kNoVolume);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
myDstMedia = NewTrackMedia(myDstTrack, myType, GetMediaTimeScale(mySrcMedia), myMediaRef, rAliasType);
myErr = GetMoviesError();
if (myErr != noErr)
goto bail;
CopyTrackSettings(mySrcTrack, myDstTrack);
#endif
// copy the entire source track into the destination track; this copies the track's media
// samples into the destination media file
myErr = BeginMediaEdits(myDstMedia);
if (myErr != noErr)
goto bail;
myErr = InsertTrackSegment(mySrcTrack, myDstTrack, 0, GetTrackDuration(mySrcTrack), 0);
if (myErr != noErr)
goto bail;
myErr = EndMediaEdits(myDstMedia);
if (myErr != noErr)
goto bail;
// add the movie atom to the data fork of the movie file
myErr = AddMovieResource(myDstMovie, myResRefNum, &myResID, NULL);
bail:
return(myErr);
}
ComponentResult process_stream_page__flac(OggImportGlobals *globals, StreamInfo *si, ogg_page *opg)
{
ComponentResult ret = noErr;
int ovret = 0;
Boolean loop = true;
Boolean movie_changed = false;
TimeValue movieTS = GetMovieTimeScale(globals->theMovie);
TimeValue mediaTS = 0;
TimeValue mediaTS_fl = 0.0;
ogg_packet op;
switch(si->si_flac.state) {
case kFStateReadingComments:
case kFStateReadingAdditionalMDBlocks:
ogg_stream_pagein(&si->os, opg);
break;
default:
break;
}
do {
switch(si->si_flac.state) {
case kFStateReadingComments:
ovret = ogg_stream_packetout(&si->os, &op);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
ret = CreateTrackAndMedia(globals, si, opg);
if (ret != noErr) {
dbg_printf("??? -- CreateTrackAndMedia failed?: %ld\n", (long)ret);
loop = false;
break;
}
if (si->si_flac.metablocks == 0 && (*((unsigned char*) op.packet) == 0xff)) {
si->si_flac.metablocks = si->si_flac.skipped;
si->si_flac.state = kFStateReadingAdditionalMDBlocks;
break;
}
{
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeFLACMetadata) };
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
}
if (((* (char *) op.packet) & 0x7f) == 4) {
dbg_printf("! > - flac_stream_page - mb: %ld, skipped: %ld, h: %02x\n", si->si_flac.metablocks, si->si_flac.skipped,
(*(char *) op.packet) & 0x7f);
unpack_vorbis_comments(&si->si_flac.vc, ((char *) op.packet) + 4, op.bytes - 4);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_flac.vc);
//NotifyMovieChanged(globals);
}
si->si_flac.skipped += 1;
si->si_flac.state = kFStateReadingAdditionalMDBlocks;
}
break;
case kFStateReadingAdditionalMDBlocks:
dbg_printf("! -- - flac_stream_page - mb: %ld, skipped: %ld\n", si->si_flac.metablocks, si->si_flac.skipped);
if (si->si_flac.metablocks > 0 && si->si_flac.skipped >= si->si_flac.metablocks) {
unsigned long endAtom[2] = { EndianU32_NtoB(sizeof(endAtom)), EndianU32_NtoB(kAudioTerminatorAtomType) };
ret = PtrAndHand(endAtom, si->soundDescExtension, sizeof(endAtom));
if (ret == noErr) {
ret = AddSoundDescriptionExtension((SoundDescriptionHandle) si->sampleDesc,
si->soundDescExtension, siDecompressionParams);
//dbg_printf("??? -- Adding extension: %ld\n", ret);
} else {
//dbg_printf("??? -- Hmm, something went wrong: %ld\n", ret);
}
si->insertTime = 0;
si->streamOffset = globals->currentGroupOffset;
mediaTS = GetMediaTimeScale(si->theMedia);
mediaTS_fl = (Float64) mediaTS;
si->streamOffsetSamples = (TimeValue) (mediaTS_fl * globals->currentGroupOffsetSubSecond) -
((globals->currentGroupOffset % movieTS) * mediaTS / movieTS);
dbg_printf("---/ / streamOffset: [%ld, %ld], %lg\n", si->streamOffset, si->streamOffsetSamples, globals->currentGroupOffsetSubSecond);
si->incompleteCompensation = 0;
si->si_flac.state = kFStateReadingFirstPacket;
loop = false; // the audio data is supposed to start on a fresh page
break;
}
ovret = ogg_stream_packetout(&si->os, &op);
dbg_printf("! -- - flac_stream_page - ovret: %d\n", ovret);
if (ovret < 0) {
loop = false;
ret = invalidMedia;
} else if (ovret < 1) {
loop = false;
} else {
// not much here so far, basically just skip the extra header packet
unsigned long atomhead[2] = { EndianU32_NtoB(op.bytes + sizeof(atomhead)), EndianU32_NtoB(kCookieTypeFLACMetadata) };
if (si->si_flac.metablocks == 0 && (* (unsigned char*) op.packet) == 0xff) {
si->si_flac.metablocks = si->si_flac.skipped;
break;
}
PtrAndHand(atomhead, si->soundDescExtension, sizeof(atomhead));
PtrAndHand(op.packet, si->soundDescExtension, op.bytes);
if (((* (unsigned char *) op.packet) & 0x7f) == 4) {
dbg_printf("! > - flac_stream_page - mb: %ld, skipped: %ld, h: %02x\n", si->si_flac.metablocks, si->si_flac.skipped,
(*(char *) op.packet) & 0x7f);
unpack_vorbis_comments(&si->si_flac.vc, ((char *) op.packet) + 4, op.bytes - 4);
/*err =*/ DecodeCommentsQT(globals, si, &si->si_flac.vc);
//NotifyMovieChanged(globals);
}
si->si_flac.skipped += 1;
}
break;
case kFStateReadingFirstPacket:
// what to do with this one? is it needed at all??
if (ogg_page_pageno(opg) > 2 && false) {
si->lastGranulePos = ogg_page_granulepos(opg);
dbg_printf("----==< skipping: %llx, %lx\n", si->lastGranulePos, ogg_page_pageno(opg));
loop = false;
if (si->lastGranulePos < 0)
si->lastGranulePos = 0;
}
si->si_flac.state = kFStateReadingPackets;
break;
case kFStateReadingPackets:
{
ogg_int64_t pos = ogg_page_granulepos(opg);
int len = opg->header_len + opg->body_len;
TimeValue duration = pos - si->lastGranulePos;
short smp_flags = 0;
if (ogg_page_continued(opg) || si->incompleteCompensation != 0)
smp_flags |= mediaSampleNotSync;
if (duration <= 0) {
duration = INCOMPLETE_PAGE_DURATION;
si->incompleteCompensation -= INCOMPLETE_PAGE_DURATION;
} else if (si->incompleteCompensation != 0) {
duration += si->incompleteCompensation;
si->incompleteCompensation = 0;
if (duration <= 0) {
ret = badFileFormat;
loop = false;
break;
}
}
if (si->insertTime == 0 && si->streamOffsetSamples > 0) {
dbg_printf(" - :++: increasing duration (%ld) by sampleOffset: %ld\n", duration, si->streamOffsetSamples);
duration += si->streamOffsetSamples;
}
ret = _store_sample_reference(si, &globals->dataOffset, len, duration, smp_flags);
if (ret != noErr) {
loop = false;
break;
}
if (!globals->usingIdle) {
#if !defined(XIPHQT_FORCE_SINGLE_SAMPLE_REF)
if (si->sample_refs_count >= si->sample_refs_size)
//if (si->sample_refs_count >= kFSRefsInitial)
#endif
{
ret = _commit_srefs(globals, si, &movie_changed);
}
}
if (pos != -1)
si->lastGranulePos = pos;
}
loop = false;
break;
default:
loop = false;
}
} while(loop);
if (movie_changed)
NotifyMovieChanged(globals, false);
return ret;
};
float quicktime_player::get_fps() {
long sampleCount = GetMediaSampleCount(m->media);
TimeScale timeScale = GetMediaTimeScale(m->media);
TimeValue duration = GetMediaDuration(m->media);
return float(sampleCount) * timeScale / duration;
}
/* Import function for movies that lack an index.
* Supports progressive importing, but will not idle if maxFrames == 0.
*/
ComponentResult import_with_idle(ff_global_ptr storage, long inFlags, long *outFlags, int minFrames, int maxFrames, bool addSamples) {
SampleReference64Record sampleRec;
AVFormatContext *formatContext;
AVCodecContext *codecContext;
AVStream *stream;
AVPacket packet;
NCStream *ncstream;
ComponentResult dataResult; //used for data handler operations that can fail.
ComponentResult result;
TimeValue minLoadedTime;
TimeValue movieTimeScale = GetMovieTimeScale(storage->movie);
int64_t availableSize, margin;
long idling;
int readResult, framesProcessed, i;
int firstPts[storage->map_count];
short flags;
formatContext = storage->format_context;
result = noErr;
minLoadedTime = -1;
availableSize = 0;
idling = (inFlags & movieImportWithIdle);
framesProcessed = 0;
if(idling) {
//get the size of immediately available data
if(storage->dataHandlerSupportsWideOffsets) {
wide wideSize;
dataResult = DataHGetAvailableFileSize64(storage->dataHandler, &wideSize);
if(dataResult == noErr) availableSize = ((int64_t)wideSize.hi << 32) + wideSize.lo;
} else {
long longSize;
dataResult = DataHGetAvailableFileSize(storage->dataHandler, &longSize);
if(dataResult == noErr) availableSize = longSize;
}
}
for(i = 0; i < storage->map_count; i++) {
ncstream = &storage->stream_map[i];
Media media = ncstream->media;
firstPts[i] = -1;
if(media && ncstream->duration == -1)
ncstream->duration = GetMediaDuration(media);
}
while((readResult = av_read_frame(formatContext, &packet)) == 0) {
bool trustPacketDuration = true;
int64_t dts = packet.dts;
ncstream = &storage->stream_map[packet.stream_index];
stream = ncstream->str;
codecContext = stream->codec;
flags = 0;
if (!ncstream->valid)
continue;
if((packet.flags & AV_PKT_FLAG_KEY) == 0)
flags |= mediaSampleNotSync;
if(IS_NUV(storage->componentType) && codecContext->codec_id == CODEC_ID_MP3) trustPacketDuration = false;
if(IS_FLV(storage->componentType)) trustPacketDuration = false;
memset(&sampleRec, 0, sizeof(sampleRec));
sampleRec.dataOffset.hi = packet.pos >> 32;
sampleRec.dataOffset.lo = (uint32_t)packet.pos;
sampleRec.dataSize = packet.size;
sampleRec.sampleFlags = flags;
if (packet.pos <= 0)
continue;
if(firstPts[packet.stream_index] < 0)
firstPts[packet.stream_index] = packet.pts;
if(packet.size > storage->largestPacketSize)
storage->largestPacketSize = packet.size;
if(sampleRec.dataSize <= 0)
continue;
if(codecContext->codec_type == AVMEDIA_TYPE_AUDIO && !ncstream->vbr)
sampleRec.numberOfSamples = (packet.size * ncstream->asbd.mFramesPerPacket) / ncstream->asbd.mBytesPerPacket;
else
sampleRec.numberOfSamples = 1; //packet.duration;
//add any samples waiting to be added
if(ncstream->lastSample.numberOfSamples > 0) {
//calculate the duration of the sample before adding it
ncstream->lastSample.durationPerSample = (dts - ncstream->lastdts) * ncstream->base.num;
AddMediaSampleReferences64(ncstream->media, ncstream->sampleHdl, 1, &ncstream->lastSample, NULL);
}
#if 0
if (0) {
Codecprintf(NULL, "Stream:%d Pts:%lld Dts:%lld DtsUsed:%lld Pos:%lld Size:%d\n", packet.stream_index, packet.pts, packet.dts, dts, packet.pos, packet.size);
Codecprintf(NULL, "Stream:%d Nsamples:%ld RealDuration:%d CalcDuration:%ld TimeDts:%lld TimeDurations:%lld FrameDts:%d FrameGuess:%lld\n",
packet.stream_index, sampleRec.numberOfSamples, packet.duration, ncstream->lastSample.durationPerSample,
packet.dts, ncstream->timeByDurations, (int)((packet.dts * stream->time_base.num * ncstream->asbd.mSampleRate) / stream->time_base.den),
ncstream->timeByFrames);
ncstream->timeByDurations += packet.duration;
ncstream->timeByFrames += ncstream->asbd.mFramesPerPacket;
}
#endif
ncstream->lastSample = sampleRec;
ncstream->lastdts = packet.dts;
// If this is a nuv file, then we want to set the duration to zero.
// This is because the nuv container doesn't have the framesize info
// for audio.
if(packet.duration == 0 || !trustPacketDuration) {
//no duration, we'll have to wait for the next packet to calculate it
// keep the duration of the last sample, so we can use it if it's the last frame
sampleRec.durationPerSample = ncstream->lastSample.durationPerSample;
} else {
ncstream->lastSample.numberOfSamples = 0;
if(codecContext->codec_type == AVMEDIA_TYPE_AUDIO && !ncstream->vbr)
sampleRec.durationPerSample = 1;
else
sampleRec.durationPerSample = ncstream->base.num * packet.duration;
AddMediaSampleReferences64(ncstream->media, ncstream->sampleHdl, 1, &sampleRec, NULL);
}
framesProcessed++;
//if we're idling, try really not to read past the end of available data
//otherwise we will cause blocking i/o.
if(idling && framesProcessed >= minFrames && availableSize > 0 && availableSize < storage->dataSize) {
margin = availableSize - (packet.pos + packet.size);
if(margin < (storage->largestPacketSize * 8)) { // 8x fudge factor for comfortable margin, could be tweaked.
av_free_packet(&packet);
break;
}
}
av_free_packet(&packet);
//stop processing if we've hit the max frame limit
if(maxFrames > 0 && framesProcessed >= maxFrames)
break;
}
if(readResult != 0) {
//if readResult != 0, we've hit the end of the stream.
//add any pending last frames.
for(i = 0; i < formatContext->nb_streams; i++) {
ncstream = &storage->stream_map[i];
if(ncstream->lastSample.numberOfSamples > 0)
AddMediaSampleReferences64(ncstream->media, ncstream->sampleHdl, 1, &ncstream->lastSample, NULL);
}
}
for(i = 0; i < storage->map_count && result == noErr; i++) {
ncstream = &storage->stream_map[i];
Media media = ncstream->media;
if(ncstream->valid && (addSamples || readResult != 0)) {
Track track = GetMediaTrack(media);
TimeScale mediaTimeScale = GetMediaTimeScale(media);
TimeValue prevDuration = ncstream->duration;
TimeValue mediaDuration = GetMediaDuration(media);
TimeValue addedDuration = mediaDuration - prevDuration;
TimeValue mediaLoadedTime = movieTimeScale * mediaDuration / mediaTimeScale;
if(minLoadedTime == -1 || mediaLoadedTime < minLoadedTime)
minLoadedTime = mediaLoadedTime;
if(addedDuration > 0) {
result = InsertMediaIntoTrack(track, -1, prevDuration, addedDuration, fixed1);
}
if (!prevDuration && firstPts[i] > 0) {
TimeRecord startTimeRec;
startTimeRec.value.hi = 0;
startTimeRec.value.lo = firstPts[i] * formatContext->streams[i]->time_base.num;
startTimeRec.scale = formatContext->streams[i]->time_base.den;
startTimeRec.base = NULL;
ConvertTimeScale(&startTimeRec, movieTimeScale);
SetTrackOffset(track, startTimeRec.value.lo);
}
ncstream->duration = -1;
}
}
//set the loaded time to the length of the shortest track.
if(minLoadedTime > 0)
storage->loadedTime = minLoadedTime;
if(readResult != 0) {
//remove the placeholder track
if(storage->placeholderTrack != NULL) {
DisposeMovieTrack(storage->placeholderTrack);
storage->placeholderTrack = NULL;
}
//set the movie load state to complete, as well as mark the import output flag.
storage->movieLoadState = kMovieLoadStateComplete;
*outFlags |= movieImportResultComplete;
} else {
//if we're not yet done with the import, calculate the movie load state.
int64_t timeToCompleteFile; //time until the file should be completely available, in terms of AV_TIME_BASE
long dataRate = 0;
dataResult = DataHGetDataRate(storage->dataHandler, 0, &dataRate);
if(dataResult == noErr && dataRate > 0) {
timeToCompleteFile = (AV_TIME_BASE * (storage->dataSize - availableSize)) / dataRate;
if(storage->loadedTime > (10 * GetMovieTimeScale(storage->movie)) && timeToCompleteFile < (storage->format_context->duration * .85))
storage->movieLoadState = kMovieLoadStatePlaythroughOK;
else
storage->movieLoadState = kMovieLoadStatePlayable;
} else {
storage->movieLoadState = kMovieLoadStatePlayable;
}
*outFlags |= movieImportResultNeedIdles;
}
send_movie_changed_notification(storage->movie);
//tell the idle manager to idle us again in 500ms.
if(idling && storage->idleManager && storage->isStreamed)
QTIdleManagerSetNextIdleTimeDelta(storage->idleManager, 1, 2);
return(result);
} /* import_with_idle() */
/* This function imports the avi represented by the AVFormatContext to the movie media represented
* in the map function. The aviheader_offset is used to calculate the packet offset from the
* beginning of the file. It returns whether it was successful or not (i.e. whether the file had an index) */
int import_using_index(ff_global_ptr storage, int *hadIndex, TimeValue *addedDuration) {
int j, k, l;
NCStream *map;
NCStream *ncstr;
AVFormatContext *ic;
AVStream *stream;
AVCodecContext *codec;
SampleReference64Ptr sampleRec;
int64_t header_offset, offset, duration;
short flags;
int sampleNum;
ComponentResult result = noErr;
map = storage->stream_map;
ic = storage->format_context;
header_offset = storage->header_offset;
if(*hadIndex == 0)
goto bail;
//FLVs have unusable indexes, so don't even bother.
if(storage->componentType == 'FLV ')
goto bail;
/* process each stream in ic */
for(j = 0; j < ic->nb_streams; j++) {
ncstr = &map[j];
stream = ncstr->str;
codec = stream->codec;
/* no stream we can read */
if(!ncstr->valid)
continue;
/* no index, we might as well skip */
if(stream->nb_index_entries == 0)
continue;
sampleNum = 0;
ncstr->sampleTable = calloc(stream->nb_index_entries, sizeof(SampleReference64Record));
/* now parse the index entries */
for(k = 0; k < stream->nb_index_entries; k++) {
/* file offset */
offset = header_offset + stream->index_entries[k].pos;
/* flags */
flags = 0;
if((stream->index_entries[k].flags & AVINDEX_KEYFRAME) == 0)
flags |= mediaSampleNotSync;
sampleRec = &ncstr->sampleTable[sampleNum++];
/* set as many fields in sampleRec as possible */
sampleRec->dataOffset.hi = offset >> 32;
sampleRec->dataOffset.lo = (uint32_t)offset;
sampleRec->dataSize = stream->index_entries[k].size;
sampleRec->sampleFlags = flags;
/* some samples have a data_size of zero. if that's the case, ignore them
* they seem to be used to stretch the frame duration & are already handled
* by the previous pkt */
if(sampleRec->dataSize <= 0) {
sampleNum--;
continue;
}
/* switch for the remaining fields */
if(codec->codec_type == AVMEDIA_TYPE_VIDEO) {
/* Calculate the frame duration */
duration = 1;
for(l = k+1; l < stream->nb_index_entries; l++) {
if(stream->index_entries[l].size > 0)
break;
duration++;
}
sampleRec->durationPerSample = map->base.num * duration;
sampleRec->numberOfSamples = 1;
}
else if(codec->codec_type == AVMEDIA_TYPE_AUDIO) {
/* FIXME: check if that's really the right thing to do here */
if(ncstr->vbr) {
sampleRec->numberOfSamples = 1;
if (k + 1 < stream->nb_index_entries)
sampleRec->durationPerSample = (stream->index_entries[k+1].timestamp - stream->index_entries[k].timestamp) * ncstr->base.num;
else if (sampleNum - 2 >= 0)
// if we're at the last index entry, use the duration of the previous sample
// FIXME: this probably could be better
sampleRec->durationPerSample = ncstr->sampleTable[sampleNum-2].durationPerSample;
} else {
sampleRec->durationPerSample = 1;
sampleRec->numberOfSamples = (stream->index_entries[k].size * ncstr->asbd.mFramesPerPacket) / ncstr->asbd.mBytesPerPacket;
}
}
}
if(sampleNum != 0)
{
/* Add all of the samples to the media */
AddMediaSampleReferences64(ncstr->media, ncstr->sampleHdl, sampleNum, ncstr->sampleTable, NULL);
/* The index is both present and not empty */
*hadIndex = 1;
}
free(ncstr->sampleTable);
}
if(*hadIndex == 0)
//No index, the remainder of this function will fail.
goto bail;
// insert media and set addedDuration;
for(j = 0; j < storage->map_count && result == noErr; j++) {
ncstr = &map[j];
if(ncstr->valid) {
Media media = ncstr->media;
Track track;
TimeRecord time;
TimeValue mediaDuration;
TimeScale mediaTimeScale;
TimeScale movieTimeScale;
int startTime = map[j].str->index_entries[0].timestamp;
mediaDuration = GetMediaDuration(media);
mediaTimeScale = GetMediaTimeScale(media);
movieTimeScale = GetMovieTimeScale(storage->movie);
/* we could handle this stream.
* convert the atTime parameter to track scale.
* FIXME: check if that's correct */
time.value.hi = 0;
time.value.lo = storage->atTime;
time.scale = movieTimeScale;
time.base = NULL;
ConvertTimeScale(&time, mediaTimeScale);
track = GetMediaTrack(media);
result = InsertMediaIntoTrack(track, time.value.lo, 0, mediaDuration, fixed1);
// set audio/video start delay
// note str.start_time exists but is always 0 for AVI
if (startTime) {
TimeRecord startTimeRec;
startTimeRec.value.hi = 0;
startTimeRec.value.lo = startTime * map[j].str->time_base.num;
startTimeRec.scale = map[j].str->time_base.den;
startTimeRec.base = NULL;
ConvertTimeScale(&startTimeRec, movieTimeScale);
SetTrackOffset(track, startTimeRec.value.lo);
}
if(result != noErr)
goto bail;
time.value.hi = 0;
time.value.lo = mediaDuration;
time.scale = mediaTimeScale;
time.base = NULL;
ConvertTimeScale(&time, movieTimeScale);
if(time.value.lo > *addedDuration)
*addedDuration = time.value.lo;
}
}
storage->loadedTime = *addedDuration;
bail:
return result;
} /* import_using_index() */
