void MovieGlHap::allocateVisualContext()
{
// Load HAP Movie
if( HapQTQuickTimeMovieHasHapTrackPlayable( getObj()->mMovie ) )
{
// QT Visual Context attributes
OSStatus err = noErr;
QTVisualContextRef * visualContext = (QTVisualContextRef*)&getObj()->mVisualContext;
CFDictionaryRef pixelBufferOptions = HapQTCreateCVPixelBufferOptionsDictionary();
const CFStringRef keys[] = { kQTVisualContextPixelBufferAttributesKey };
CFDictionaryRef visualContextOptions = ::CFDictionaryCreate(kCFAllocatorDefault, (const void**)&keys, (const void**)&pixelBufferOptions, sizeof(keys)/sizeof(keys[0]), &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
err = QTPixelBufferContextCreate( kCFAllocatorDefault, visualContextOptions, visualContext );
::CFRelease( pixelBufferOptions );
::CFRelease( visualContextOptions );
if( err != noErr ) {
CI_LOG_E( "HAP ERROR :: " << err << " couldnt create visual context." );
return;
}
// Set the movie's visual context
err = SetMovieVisualContext( getObj()->mMovie, *visualContext );
if( err != noErr ) {
CI_LOG_E( "HAP ERROR :: " << err << " SetMovieVisualContext." );
return;
}
}
// Get codec name
for (long i = 1; i <= GetMovieTrackCount(getObj()->mMovie); i++) {
Track track = GetMovieIndTrack(getObj()->mMovie, i);
Media media = GetTrackMedia(track);
OSType mediaType;
GetMediaHandlerDescription(media, &mediaType, NULL, NULL);
if (mediaType == VideoMediaType)
{
// Get the codec-type of this track
ImageDescriptionHandle imageDescription = (ImageDescriptionHandle)NewHandle(0); // GetMediaSampleDescription will resize it
GetMediaSampleDescription(media, 1, (SampleDescriptionHandle)imageDescription);
OSType codecType = (*imageDescription)->cType;
DisposeHandle((Handle)imageDescription);
switch (codecType) {
case 'Hap1': mCodec = Codec::HAP; break;
case 'Hap5': mCodec = Codec::HAP_A; break;
case 'HapY': mCodec = Codec::HAP_Q; break;
default: mCodec = Codec::UNSUPPORTED; break;
}
}
}
// Set framerate callback
this->setNewFrameCallback( updateMovieFPS, (void*)this );
}
/*
call-seq: media_type() -> media_type_sym
Returns either :audio or :video depending on the type of track this is.
*/
static VALUE track_media_type(VALUE obj)
{
OSType media_type;
GetMediaHandlerDescription(TRACK_MEDIA(obj), &media_type, 0, 0);
if (media_type == SoundMediaType) {
return ID2SYM(rb_intern("audio"));
} else if (media_type == VideoMediaType) {
return ID2SYM(rb_intern("video"));
} else if (media_type == TextMediaType) {
return ID2SYM(rb_intern("text"));
} else {
return Qnil;
}
}
/* helper function, returns media type of the track
*/
static OSType track_get_media_type(VALUE obj)
{
OSType media_type;
GetMediaHandlerDescription(TRACK_MEDIA(obj), &media_type, 0, 0);
return media_type;
}
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;
}
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 FFAvi_MovieImportDataRef(ff_global_ptr storage, Handle dataRef, OSType dataRefType, Movie theMovie, Track targetTrack,
Track *usedTrack, TimeValue atTime, TimeValue *addedDuration, long inFlags, long *outFlags)
{
ComponentResult result = noErr;
ByteIOContext *byteContext;
AVFormatContext *ic = NULL;
AVFormatParameters params;
OSType mediaType;
Media media;
int count, hadIndex, j;
/* make sure that in case of error, the flag movieImportResultComplete is not set */
*outFlags = 0;
/* probe the format first */
UInt8 valid = 0;
FFAvi_MovieImportValidateDataRef(storage, dataRef, dataRefType, &valid);
if(valid != 255)
goto bail;
/* Prepare the iocontext structure */
result = url_open_dataref(&byteContext, dataRef, dataRefType, &storage->dataHandler, &storage->dataHandlerSupportsWideOffsets, &storage->dataSize);
storage->isStreamed = dataRefType == URLDataHandlerSubType;
require_noerr(result, bail);
/* Open the Format Context */
memset(¶ms, 0, sizeof(params));
result = av_open_input_stream(&ic, byteContext, "", storage->format, ¶ms);
require_noerr(result,bail);
storage->format_context = ic;
// AVIs without an index currently add a few entries to the index so it can
// determine codec parameters. Check for index existence here before it
// reads any packets.
hadIndex = 1;
for (j = 0; j < ic->nb_streams; j++) {
if (ic->streams[j]->nb_index_entries <= 1)
{
hadIndex = 0;
break;
}
}
/* Get the Stream Infos if not already read */
result = av_find_stream_info(ic);
// -1 means it couldn't understand at least one stream
// which might just mean we don't have its video decoder enabled
if(result < 0 && result != -1)
goto bail;
// we couldn't find any streams, bail with an error.
if(ic->nb_streams == 0) {
result = -1; //is there a more appropriate error code?
goto bail;
}
//determine a header offset (needed by index-based import).
result = determine_header_offset(storage);
if(result < 0)
goto bail;
/* Initialize the Movie */
storage->movie = theMovie;
if(inFlags & movieImportMustUseTrack) {
storage->map_count = 1;
prepare_track(storage, targetTrack, dataRef, dataRefType);
} else {
storage->map_count = ic->nb_streams;
result = prepare_movie(storage, theMovie, dataRef, dataRefType);
if (result != 0)
goto bail;
}
/* replace the SampleDescription if user called MovieImportSetSampleDescription() */
if(storage->imgHdl) {
for(j = 0; j < storage->map_count; j++) {
NCStream ncstream = storage->stream_map[j];
GetMediaHandlerDescription(ncstream.media, &mediaType, NULL, NULL);
if(mediaType == VideoMediaType && ncstream.sampleHdl) {
DisposeHandle((Handle)ncstream.sampleHdl);
ncstream.sampleHdl = (SampleDescriptionHandle)storage->imgHdl;
}
}
}
if(storage->sndHdl) {
for(j = 0; j < storage->map_count; j++) {
NCStream ncstream = storage->stream_map[j];
GetMediaHandlerDescription(ncstream.media, &mediaType, NULL, NULL);
if(mediaType == SoundMediaType && ncstream.sampleHdl) {
DisposeHandle((Handle)ncstream.sampleHdl);
ncstream.sampleHdl = (SampleDescriptionHandle)storage->sndHdl;
}
}
}
count = 0; media = NULL;
for(j = 0; j < storage->map_count; j++) {
media = storage->stream_map[j].media;
if(media)
count++;
}
if(count > 1)
*outFlags |= movieImportResultUsedMultipleTracks;
/* The usedTrack parameter. Count the number of Tracks and set usedTrack if we operated
* on a single track. Note that this requires the media to be set by track counting above*/
if(usedTrack && count == 1 && media)
*usedTrack = GetMediaTrack(media);
result = noErr;
*addedDuration = 0;
//attempt to import using indexes.
result = import_using_index(storage, &hadIndex, addedDuration);
require_noerr(result, bail);
if(hadIndex) {
//file had an index and was imported; we are done.
*outFlags |= movieImportResultComplete;
} else if(inFlags & movieImportWithIdle) {
if(addedDuration && ic->duration > 0) {
TimeScale movieTimeScale = GetMovieTimeScale(theMovie);
*addedDuration = movieTimeScale * ic->duration / AV_TIME_BASE;
//create a placeholder track so that progress displays correctly.
create_placeholder_track(storage->movie, &storage->placeholderTrack, *addedDuration, dataRef, dataRefType);
//give the data handler a hint as to how fast we need the data.
//suggest a speed that's faster than the bare minimum.
//if there's an error, the data handler probably doesn't support
//this, so we can just ignore.
DataHPlaybackHints(storage->dataHandler, 0, 0, -1, (storage->dataSize * 1.15) / ((double)ic->duration / AV_TIME_BASE));
}
//import with idle. Decode a little bit of data now.
import_with_idle(storage, inFlags, outFlags, 10, 300, true);
} else {
//QuickTime didn't request import with idle, so do it all now.
import_with_idle(storage, inFlags, outFlags, 0, 0, true);
}
LoadExternalSubtitlesFromFileDataRef(dataRef, dataRefType, theMovie);
bail:
if(result == noErr)
storage->movieLoadState = kMovieLoadStateLoaded;
else
storage->movieLoadState = kMovieLoadStateError;
if (result == -1)
result = invalidMovie; // a bit better error message
return result;
} /* FFAvi_MovieImportDataRef */