include <ofQtUtils.h>
  include <ofUtils.h>
  
  ifndef TARGET_LINUX
  static bool bQuicktimeInitialized = false;
  
  //----------------------------------------
  void initializeQuicktime(){
          if (bQuicktimeInitialized == false){
  
                  //----------------------------------
                  // do we have quicktime installed at all?
                  // http://www.apple.com/quicktime/download/win.html
  		// can gestalt help with versions, or is that only after init?
  
                  OSErr myErr         = noErr;
                  #ifdef TARGET_WIN32
                          myErr = InitializeQTML(0);
                          if (myErr != noErr){
                                  ofLog(OF_LOG_ERROR, "-----------------------------------------------------");
                                  ofLog(OF_LOG_ERROR, "sorry, there is a problem with quicktime starting up... please check!");
                  OF_EXIT_APP(0);
                          }
                  #endif
                  myErr = EnterMovies ();
                  if (myErr != noErr){
                          ofLog(OF_LOG_ERROR, "-----------------------------------------------------");
                          ofLog(OF_LOG_ERROR, "sorry, there is a problem with quicktime starting up... please check!");
                          OF_EXIT_APP(0);
                  }
  
                  bQuicktimeInitialized = true;
          }
  }
  
  //----------------------------------------
  void closeQuicktime(){
          if (bQuicktimeInitialized == true){
                  ExitMovies();
                  #ifdef TARGET_WIN32
                          TerminateQTML();
                  #endif
                  bQuicktimeInitialized = false;
          }
  }
  
  //----------------------------------------
  void convertPixels(unsigned char * gWorldPixels, unsigned char * rgbPixels, int w, int h){
  
          // ok for macs?
          // ok for intel macs?
  
          int * rgbaPtr                         = (int *) gWorldPixels;
          pix24 * rgbPtr                         = (pix24 *) rgbPixels;
                  unsigned char * rgbaStart;
  
          //        putting in the boolean, so we can work on
          //        0,0 in top right...
          //        bool bFlipVertically         = true;
  
          bool bFlipVertically         = false;
  
          // -------------------------------------------
          // we flip vertically because the 0,0 position in OF
          // is the bottom left (not top left, like processing)
          // since the 0,0 of a picture is top left
          // if we upload and drawf the data as is
          // it will be upside-down....
          // -------------------------------------------
  
          if (!bFlipVertically){
                  //----- argb->rgb
                  for (int i = 0; i < h; i++){
                          pix24 * rgbPtr                         = (pix24 *) rgbPixels + ((i) * w);
                          for (int j = 0; j < w; j++){
                                  rgbaStart = (unsigned char *)rgbaPtr;
                                  memcpy (rgbPtr, rgbaStart+1, sizeof(pix24));
                                  rgbPtr++;
                                  rgbaPtr++;
                          }
                  }
          } else {
                  //----- flip while argb->rgb
                  for (int i = 0; i < h; i++){
                          pix24 * rgbPtr                         = (pix24 *) rgbPixels + ((h-i-1) * w);
                          for (int j = 0; j < w; j++){
                                  rgbaStart = (unsigned char *)rgbaPtr;
                                  memcpy (rgbPtr, rgbaStart+1, sizeof(pix24));
                                  rgbPtr++;
                                  rgbaPtr++;
                          }
                  }
          }
  }
  
  //----------------------------------------
  // osx needs this for modal dialogs.
  Boolean SeqGrabberModalFilterUPP (DialogPtr theDialog, const EventRecord *theEvent, short *itemHit, long refCon){
          #pragma unused(theDialog, itemHit)
            Boolean  handled = false;
            if ((theEvent->what == updateEvt) &&
      ((WindowPtr) theEvent->message == (WindowPtr) refCon))
            {
              BeginUpdate ((WindowPtr) refCon);
              EndUpdate ((WindowPtr) refCon);
              handled = true;
            }
            return (handled);
  }
  
  define   kCharacteristicHasVideoFrameRate                FOUR_CHAR_CODE('vfrr')
  define   kCharacteristicIsAnMpegTrack                        FOUR_CHAR_CODE('mpeg')
  
  /*
  
  Calculate the static frame rate for a given movie.
  
  */
  void MovieGetStaticFrameRate(Movie inMovie, double *outStaticFrameRate)
  {
  
    *outStaticFrameRate = 0;
  
    Media movieMedia;
    MediaHandler movieMediaHandler;
    /* get the media identifier for the media that contains the first
      video track's sample data, and also get the media handler for
      this media. */
    MovieGetVideoMediaAndMediaHandler(inMovie, &movieMedia, &movieMediaHandler);
    if (movieMedia && movieMediaHandler)
    {
      Boolean isMPEG = false;
      /* is this the MPEG-1/MPEG-2 media handler? */
      OSErr err = IsMPEGMediaHandler(movieMediaHandler, &isMPEG);
      if (err == noErr)
      {
        if (isMPEG) /* working with MPEG-1/MPEG-2 media */
        {
          Fixed staticFrameRate;
          ComponentResult err = MPEGMediaGetStaticFrameRate(movieMediaHandler, &staticFrameRate);
          if (err == noErr)
          {
            /* convert Fixed data result to type double */
            *outStaticFrameRate = Fix2X(staticFrameRate);
          }
        }
        else  /* working with non-MPEG-1/MPEG-2 media */
        {
          OSErr err = MediaGetStaticFrameRate(movieMedia, outStaticFrameRate);
          if (err != noErr) ofLog(OF_LOG_ERROR, "error in MediaGetStaticFrameRate, ofQtUtils");
          //assert(err == noErr);
        }
      }
    }
  }
  
  /*
  
  Get the media identifier for the media that contains the first
  video track's sample data, and also get the media handler for
  this media.
  
  */
  void MovieGetVideoMediaAndMediaHandler(Movie inMovie, Media *outMedia, MediaHandler *outMediaHandler)
  {
  
    *outMedia = NULL;
    *outMediaHandler = NULL;
  
    /* get first video track */
    Track videoTrack = GetMovieIndTrackType(inMovie, 1, kCharacteristicHasVideoFrameRate,
                movieTrackCharacteristic | movieTrackEnabledOnly);
    if (videoTrack != NULL)
    {
      /* get media ref. for track's sample data */
      *outMedia = GetTrackMedia(videoTrack);
      if (*outMedia)
      {
        /* get a reference to the media handler component */
        *outMediaHandler = GetMediaHandler(*outMedia);
      }
    }
  }
  
  /*
  
  Return true if media handler reference is from the MPEG-1/MPEG-2 media handler.
  Return false otherwise.
  
  */
  OSErr IsMPEGMediaHandler(MediaHandler inMediaHandler, Boolean *outIsMPEG)
  {
  
            /* is this the MPEG-1/MPEG-2 media handler? */
          return((OSErr) MediaHasCharacteristic(inMediaHandler,
                                          kCharacteristicIsAnMpegTrack,
                                          outIsMPEG));
  }
  
  /*
  
  Given a reference to the media handler used for media in a MPEG-1/MPEG-2
  track, return the static frame rate.
  
  */
  ComponentResult MPEGMediaGetStaticFrameRate(MediaHandler inMPEGMediaHandler, Fixed *outStaticFrameRate)
  {
    *outStaticFrameRate = 0;
  
    MHInfoEncodedFrameRateRecord encodedFrameRate;
    Size encodedFrameRateSize = sizeof(encodedFrameRate);
  
      /* get the static frame rate */
    ComponentResult err = MediaGetPublicInfo(inMPEGMediaHandler,
                         kMHInfoEncodedFrameRate,
                         &encodedFrameRate,
                         &encodedFrameRateSize);
    if (err == noErr)
    {
      /* return frame rate at which the track was encoded */
      *outStaticFrameRate = encodedFrameRate.encodedFrameRate;
    }
  
    return err;
  }
  
  /*
  
  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;
  }
  
  //----------------------------------------
  
  ifdef TARGET_OSX
  // GetSettingsPreference
  //    Returns a preference for a specified key as QuickTime UserData
  // It is your responsibility to dispose of the returned UserData
  OSErr GetSettingsPreference(CFStringRef inKey, UserData *outUserData)
  {
    CFPropertyListRef theCFSettings;
    Handle            theHandle = NULL;
    UserData          theUserData = NULL;
    OSErr             err = paramErr;
  
    // read the new setttings from our preferences
    theCFSettings = CFPreferencesCopyAppValue(inKey,
                                           kCFPreferencesCurrentApplication);
    if (theCFSettings) {
      err = PtrToHand(CFDataGetBytePtr((CFDataRef)theCFSettings), &theHandle,
                      CFDataGetLength((CFDataRef)theCFSettings));
  
      CFRelease(theCFSettings);
      if (theHandle) {
        err = NewUserDataFromHandle(theHandle, &theUserData);
        if (theUserData) {
          *outUserData = theUserData;
        }
        DisposeHandle(theHandle);
      }
    }
  
    return err;
  }
  
  //----------------------------------------
  // SaveSettingsPreference
  //    Saves a preference for a specified key from QuickTime UserData
  OSErr SaveSettingsPreference(CFStringRef inKey, UserData inUserData)
  {
    CFDataRef theCFSettings;
    Handle    hSettings;
    OSErr     err;
  
    if (NULL == inUserData) return paramErr;
  
    hSettings = NewHandle(0);
    err = MemError();
  
    if (noErr == err) {
      err = PutUserDataIntoHandle(inUserData, hSettings);
  
      if (noErr == err) {
        HLock(hSettings);
  
        theCFSettings = CFDataCreate(kCFAllocatorDefault,
                                     (UInt8 *)*hSettings,
                                     GetHandleSize(hSettings));
        if (theCFSettings) {
          CFPreferencesSetAppValue(inKey, theCFSettings,
                                   kCFPreferencesCurrentApplication);
          CFPreferencesAppSynchronize(kCFPreferencesCurrentApplication);
          CFRelease(theCFSettings);
        }
      }
  
      DisposeHandle(hSettings);
    }
  
    return err;
  }
  
  //end mac specific stuff
  endif
  
  endif