Hardware and Software Requirements

QuickTime 7 for Windows requires the following minimum configuration:

• Windows 2000 or Windows XP

• Pentium processor or other processor equivalent

• At least 128 MB of RAM

New Pro Key Required

QuickTime 7 for Windows replaces existing point releases of QuickTime 6 for Windows. A new Pro key is required; QuickTime 6 Pro keys will not unlock the Pro features of QuickTime 7 for Windows.

New Features of QuickTime 7 for Windows

This release of QuickTime includes a number of major new features for users, developers, and content creators, including improvements in the QuickTime architecture, file format, user interface, and API. There are significant improvements in the audio, video, and metadata capabilities, as well as a new APIs, and numerous other enhancements.

• Changes to QuickTime Player and QuickTime Pro describes the new user interface for QuickTime Player and QuickTime Pro and some of the changes from previous versions of the Player.

• New COM/ActiveX Control describes the new COM Control and how you can take advantage of the control using the tools available in Visual Basic .NET, C# and Visual Basic 6.

• Audio Enhancements describes the many new audio features of QuickTime 7 for Windows, including support for multichannel sound, playback, compression, and export of high-resolution audio, a new sound description, and new functions for movie audio control, audio conversion configuration, audio extraction, movie export, and level and frequency metering.

• Video Enhancements describes QuickTime’s new support for frame reordering video compression and the H.264 codec. Frame reordering support is a major advance that involves new sample tables for video, allowing video frames to have independent decode and display times. This allows improved display, editing, and compression of H.264 and other advanced video codecs. A new set of functions and structures are introduced to allow developers to work with samples that have independent decode and display times.

• Replacing NewMovieFrom... Functions describes the NewMovieFromProperties function, which allows you to set up properties before creating a movie. This function also allows you to create movies that are not necessarily associated with a graphics world, movies that can render their output to a visual context, such as an OpenGL texture buffer, and movies that play to a particular audio device.

• QuickTime Metadata Enhancements and API describes the new QuickTime extensible metadata format, allowing developers to efficiently reference text, audio, video, or other material that describes a movie, a track, or a media. Support is also added for including metadata from other file types in native format; the QuickTime 7 for Windows release includes native support for iTunes metadata.

• QuickTime Sample Table API describes the new API for working with QT Sample Tables, a logical replacement for arrays of media sample references. The new API greatly extends the functionality of media sample references, and the new API supports frame reordering compressed media.

• Other Changes and Enhancements discusses QuickTime 7’s new default install location for QuickTime, which has been moved from the directory \Windows\System32\QuickTime to \Program Files\QuickTime. A number of new APIs have been created to allow developers to locate the various directories created by the QuickTime installer. New updates and fixes to QuickTime for Java are also discussed in this section.

New Directions in QuickTime 7 for Windows

The QuickTime software architecture has been revised to expose platform-native interfaces on Windows to application developers. On Windows, this includes exposing QuickTime framework APIs via COM interfaces (ActiveX).

Key areas of change in QuickTime 7 for Windows include:

• A shift of emphasis away from the Sound Manager approach throughout QuickTime.

• A shift of emphasis toward configuring components using component properties and an abstraction layer, or context, and away from the exclusive use of standard dialogs supplemented by direct access to low-level components.

• A shift of emphasis toward a more object-oriented organization, with more high-level functionality in QuickTime itself supporting lighter-weight applications.

In Summary QuickTime 6 through QuickTime 7

The following table summarizes the point releases of QuickTime 6 and the features of QuickTime 7.

New in QuickTime Player

The new QuickTime Player is a native Windows application. The intent of this new design is to better integrate QuickTime Player in general with the Windows user experience.

The following are some of the new user-level features available in QuickTime Player:

• H.264 video support. This state-of-the-art, standards-based codec delivers exceptional-quality video at the lowest data rate possible, across the entire bandwidth spectrum.

• New audio and playback controls. Users can use the new A/V Controls window to adjust settings for the best audio and playback experience. Users can now easily change settings, including playback speed, volume, bass, treble, and balance. You can also use the jog shuttle control to easily navigate to a particular movie frame.

• Zero-configuration streaming. You no longer need to set your Internet connection speed in QuickTime Preferences. QuickTime automatically determines the best connection speed for your computer. If a connection is lost during streaming, QuickTime automatically reconnects to the server. Users can also select a preset connection speed.

• Live resize. Playback continues smoothly as you change the size of the QuickTime Player window.

• Multichannel audio. QuickTime Player can now play 24 audio channels––and beyond. With external speakers, you can enjoy the full sound effects of movies and games.

  By accessing the Window > Show Movie Properties window, selecting an audio track, and then selecting Audio Settings, you can set the volume, balance, bass, and treble for a QuickTime movie. In addition, if you select the sound track property in the window, you can set the speaker for each audio channel in that track, specifying the speaker through which the audio can be heard.

• All-new content guide. The completely redesigned QuickTime Content Guide provides the latest in news, education, and entertainment on the Internet.

New in QuickTime Pro

The following are some of the new user-level features available in the Pro version of QuickTime Player:

• Creating H.264 video. Users can take advantage of this codec for a variety of video needs, ranging from HD (high definition) to 3G (for mobile devices). This new codec provides better quality at lower bandwidth, enabling users to deliver high-quality video over the Internet.

• Creating multichannel audio. Users can create a rich multimedia experience by labeling each audio channel (for example, Left, Right, Left Surround, LFE, and so on). QuickTime automatically mixes the audio to work with the speaker setup of each user.

• Recording audio. With a digital audio device that supports USB and line-in microphones connected to your computer, you can capture and record audio. This new feature enables users to create, with a minimum of effort, podcasts for posting and publication on the Internet.

• Full screen playback enhancements. Full screen mode now provides floating controls. These include pause, play, stop, fast forward, and rewind, as well as volume for audio control. Users move the pointer to display the controller; after a few seconds, the controller fades away. Note that the controller does not appear with interactive movies when the mouse is moved, so that it does not interfere with movie content. Users can press the keyboard control-C to make it appear or disappear immediately.

  Users can access full screen mode by choosing the View > Full Screen or using its keyboard equivalent, Control-F. To display the DVD-style full screen controls, users choose QuickTime Player > Preferences > Player Preferences > Full Screen.

• Enhanced and redesigned interface for movie settings. The Movie Properties window has been redesigned to facilitate movie authoring.

• New options for image manipulation in the Visual Settings pane of the Movie Properties dialog of a video track.

  In addition, users are provided with other options to manipulate and control image transparency in QuickTime movies and image files.

Other Changes and Enhancements

The following are some additional changes and enhancements in QuickTime 7 for Windows:

• QuickTime Preferences now has the option “Use high quality video setting when available.” Users can set this as the default for displaying high-quality video tracks, such as DV.

• The Open File command enables users to open any of a number of digital media types that QuickTime supports, including movies, still images, VR panoramas, Flash, and so on.

• Choosing the File > New Audio Recording menu item enables you to record audio from an external or internal audio device. Once recording begins, a new QuickTime Player window specifically for recording appears.

• To change the audio source for your recording, or to specify the quality of recording you want, you choose QuickTime Player > Preferences > Recording.

• The Save dialog that the Save As command opens now has “Make movie as a self-contained” selected by default, which is a change from previous versions of QuickTime Player.

• Choosing the Help > Update Existing Software menu item lets you update the version to the latest version of QuickTime.

• The menu items in previous versions––Enable, Extract, and Delete––are now available in the Movie Properties window.

• There is a new command––Trim to Selection––which replaces the previous command Trim. The Replace command has been removed, which means that users can no longer perform a delete-and-paste operation as a single operation.

• The Movie menu has been renamed and is now the View menu. The Show Movie Properties command has been moved to the Windows menu.

• Choosing the Window > Show Movie Properties menu item and selecting a track enables you to specify certain properties of that track. For example, if you select Annotations and want to add a field, you have multiple choices, including Album, Artist, Author, and so on.

• Choosing the Window > Show Movie Properties menu item and selecting a track with Other Settings selected enables you to specify certain properties of that track, including language, preloading of the track, caching, and so on.

• When the user moves the mouse over a selection of the movie, ticks appear that indicate you can make a selection over that area. When you move the mouse over the playbar, the movie will appear or disappear. Users can also set in and out points now by placing the current time marker and typing I or O.

Advantages For Developers

If you are a Visual Basic programmer or enterprise software developer doing in-house development, the COM control implementation offers a number of important advantages:

• You can build Windows desktop applications more easily with Visual Basic or C#, combining QuickTime with the rich and powerful .NET Framework.

• You can write useful utility scripts for working with QuickTime in either JavaScript or VBScript. These scripts can be run within the Windows Scripting Host environment by simply double-clicking the .js or .vbs script files, or from the command line using cscript.

• You don’t have to access the low-level functionality provided by the full QuickTime API in order to use QuickTime in your application development.

For example, if your Windows server can run a Visual Basic, C#, or .js application that uses QuickTime, you have the possibility to create custom QuickTime content interactively, delivering that content over the Web. As long as your clients have QuickTime installed, your content will work with Windows and non-Windows clients, Internet Explorer and non-Internet Explorer browsers.

QuickTime Player itself uses the new QuickTime COM control for virtually all of its access to QuickTime.

How It Works

The new COM control is comprised of two separate DLLs:

• An COM/ActiveX control (QTOControl.dll) that “knows” how to open a movie and manage the interaction with the operating system and the host application.

• A COM library (QTOLibrary.dll) which provides a COM interface to a movie and to QuickTime itself.

The COM library is a very thin layer that sits on top of the low level QuickTime APIs and provides a COM wrapper object for each logical QuickTime object. Each COM object exposes the properties, methods, and notifications of the QuickTime object it wraps.

The object hierarchy is illustrated in Figure 2-1.

Note that the QTMovieEqualizer object illustrated in Figure 2-1 should be QTFrequencyMeter.

If you are a Windows developer, you know that the Component Object Model (COM) specification defines how a host application accesses the component, how the component notifies the host application of events, standard data types for data exchange with the OS or other components. A COM control is a type of COM component that has a visual display of some kind, restricting its placement to visual containers such as a form or dialog box. COM controls typically manage their own window.

In the .NET environment, the new QuickTime COM control is accessed via the .NET Framework’s COM Interop layer. Primary Interop Assemblies (.NET wrappers for COM objects) will be provided with the QuickTime 7 SDK.

AxQTControl1.Sizing = QTOControlLib.QTSizingModeEnum.qtControlFitsMovie

AxQTControl1.SetScale(2)

AxQTControl1.Sizing = QTOControlLib.QTSizingModeEnum.qtMovieFitsControl

Imports QTOControlLib

AxQTControl1.Sizing = QTSizingModeEnum.qtControlFitsMovie

AxQTControl1.SetScale(2)

AxQTControl1.Sizing = QTSizingModeEnum.qtMovieFitsControl

using QTOControlLib;

Getting Started With QuickTime COM Control

Once you instantiate the QuickTime COM control and load a movie into it, you can then get at the QTOLibrary object model via the control’s Movie property, which returns a QTMovie COM object.

To get started with the new COM control, in VB.NET or C#:

1. Create a new Windows Application project.

2. Right-click on the Windows Forms toolbox, choose Add/Remove Items... and select the COM Components tab.

3. Scroll down until you find Apple QuickTime Control 2.0.

4. Click this control and click OK to add the QuickTime control to your toolbox. You should now see a QuickTime icon.

5. Place the control on Form1.

6. Place two buttons on the form and code as follows:

 Private Sub Button1_Click(...) Handles Button1.Click

     AxQTControl1.URL = "d:\movies\sample.mov"  'Change to your own movie!

     End Sub

     Private Sub Button2_Click(...) Handles Button2.Click

         AxQTControl1.Movie.Play()

     End Sub

After you have completed these steps, you can:

1. Build and run the application.

2. Click Button1 to load a movie; then click Button2 to play the movie.

In Visual Basic 6, you need to follow these steps:

1. Create a new Standard EXE project.

2. Choose Project | Components and scroll down to the Apple QuickTime Control 2.0. Click this component and click OK to add to the Visual Basic 6 toolbox.

3. Add the QuickTime control to Form1.

4. Create two buttons and code as follows:

Private Sub Command1_Click()

          QTControl1.URL = "d:\movies\sample.mov" 'Change to your own movie!

      End Sub

      Private Sub Command2_Click()

          QTControl1.Movie.Play

      End Sub

Now you can run the application. Click Command1 to load the movie and Command2 to play the movie.

Once you have loaded a movie and have the QTMovie object from the control’s Movie property, you can proceed to delve down into the object model. For example:

 'Iterate movie tracks (VB6)

     Dim myMovie As QTMovie

     Dim t As String

     Set myMovie = QTControl1.Movie

     Dim trk As QTTrack

     Dim qtu As New QTUtils

     For Each trk In myMovie.Tracks

         t = t + "Track : " + CStr(i) + vbCrLf

         t = t + vbTab + "Type : " + qtu.FourCharCodeToString(trk.Type)

                                   + vbCrLf

         t = t + vbTab + "Format : " + trk.Format + vbCrLf

         t = t + vbTab + "Duration : " + CStr(trk.Duration) + vbCrLf

     Next trk

     txtResults = t$

In order to use the QuickTime COM object types in your Visual Basic 6 application you will need to add the QuickTime COM library to your project. Choose Project | References and add the Apple QuickTime Library 2.0.

Example Code To Create a Simple COM/ActiveX Control Application in Visual Basic 6

This section includes two code samples, one bare bones, letting you simply open and edit a QuickTime movie, and the other more fully featured. Using this example code you can create a simple COM/ActiveX control application in Visual Basic 6. The code is provided here with some comments and discussion.

Function GetFileName()

    Form1.CommonDialog1.ShowOpen

    GetFileName = Form1.CommonDialog1.FileName

End Function

Private Sub mnuEdit_Click(Index As Integer)

    Select Case Index

        Case 0  'Undo

        Case 2  'Cut

        Case 3  'Copy

        Case 4  'Paste

    End Select

End Sub

Private Sub mnuFile_Click(Index As Integer)

    Select Case Index

        Case 0  'Open

            QTControl1.URL = GetFileName()

        Case 1  'Close

        Case 3  'Full Screen

        Case 5  'Exit

            Unload Me

            End

    End Select

End Sub

Object = "{7B92F833-027D-402B-BFF9-A67697366F4E}#1.0#0"; "QTOControl.dll"

Object = "{F9043C88-F6F2-101A-A3C9-08002B2F49FB}#1.2#0"; "comdlg32.ocx"

Begin VB.Form MovieForm

   Caption         =   "Movie"

   ClientHeight    =   4260

   ClientLeft      =   132

   ClientTop       =   816

   ClientWidth     =   4080

   LinkTopic       =   "MovieForm"

   ScaleHeight     =   4260

   ScaleWidth      =   4080

   StartUpPosition =   3  'Windows Default

   Begin MSComDlg.CommonDialog CommonDialog1

      Left            =   3240

      Top             =   600

      _ExtentX        =   847

      _ExtentY        =   847

      _Version        =   393216

   End

   Begin QTOControlLibCtl.QTControl QTControl1

      Height          =   4332

      Left            =   0

      TabIndex        =   0

      Top             =   0

      Width           =   4056

      _cx             =   7154

      _cy             =   7641

      BackColor       =   -2147483644

      BorderColor     =   0

      BorderStyle     =   0

      MovieControllerVisible=   -1  'True

      Sizing          =   0

      URL             =   ""

      BaseURL         =   ""

      AutoPlay        =   ""

   End

   Begin VB.Menu mnuBar

      Caption         =   "&File"

      Index           =   0

      Begin VB.Menu mnuFile

         Caption         =   "&Open..."

         Index           =   0

         Shortcut        =   ^O

      End

      Begin VB.Menu mnuFile

         Caption         =   "Open &URL..."

         Index           =   1

      End

      Begin VB.Menu mnuFile

         Caption         =   "&Close"

         Index           =   2

      End

      Begin VB.Menu mnuFile

         Caption         =   "-"

         Index           =   3

      End

      Begin VB.Menu mnuFile

         Caption         =   "&Full Screen"

         Index           =   4

      End

      Begin VB.Menu mnuFile

         Caption         =   "Get Info"

         Index           =   5

         Shortcut        =   ^I

      End

      Begin VB.Menu mnuFile

         Caption         =   "-"

         Index           =   6

      End

      Begin VB.Menu mnuFile

         Caption         =   "Exit"

         Index           =   7

      End

   End

   Begin VB.Menu mnuBar

      Caption         =   "Edit"

      Index           =   1

      Begin VB.Menu mnuEdit

         Caption         =   "Undo"

         Index           =   0

      End

      Begin VB.Menu mnuEdit

         Caption         =   "Cut"

         Index           =   2

      End

      Begin VB.Menu mnuEdit

         Caption         =   "Copy"

         Index           =   3

      End

      Begin VB.Menu mnuEdit

         Caption         =   "Paste"

         Index           =   4

      End

   End

End

Attribute VB_Name = "MovieForm"

Attribute VB_GlobalNameSpace = False

Attribute VB_Creatable = False

Attribute VB_PredeclaredId = True

Attribute VB_Exposed = False

Option Explicit

Dim gManualFormResize As Boolean

Private Declare Function GetSystemMetrics Lib "user32" (ByVal nIndex As Long) As  Long

Private Const SM_CYCAPTION = 4

Private Const SM_CYFRAME = 33

Private Const SM_CYMENU = 15

Function GetFileName()

    MovieForm.CommonDialog1.InitDir = "d:\QuickTime\Movies"

    MovieForm.CommonDialog1.ShowOpen

    GetFileName = MovieForm.CommonDialog1.FileName

End Function

Function GetFormBorderWidth()

    GetFormBorderWidth = GetSystemMetrics(SM_CYFRAME) * 2

End Function

Function GetFormBorderHeight()

    GetFormBorderHeight = GetSystemMetrics(SM_CYCAPTION) +  GetSystemMetrics(SM_CYMENU) + (GetSystemMetrics(SM_CYFRAME) * 2)

End Function

Private Sub Form_Load()

    QTControl1.ErrorHandling = qtErrorHandlingRaiseException

    QTControl1.Sizing = qtControlFitsMovie

    Load MovieInfo

End Sub

Private Sub Form_Resize()

    Dim oldSizingMode As QTSizingModeEnum

    gManualFormResize = True  ' global flag so _SizeChanged won't respond

    ' change sizing mode so the movie tracks the control's size

    oldSizingMode = QTControl1.Sizing

    QTControl1.Sizing = qtMovieFitsControl

    QTControl1.Move 0, 0, Me.Width - (GetFormBorderWidth() *  Screen.TwipsPerPixelX), Me.Height - (GetFormBorderHeight() *  Screen.TwipsPerPixelY)

    QTControl1.Sizing = oldSizingMode

    gManualFormResize = False

End Sub

Private Sub Form_Unload(Cancel As Integer)

    MovieInfo.SetInfoMovie Nothing

    QTControl1.URL = ""

    DoEvents

    End

End Sub

Private Sub mnuEdit_Click(Index As Integer)

    If QTControl1.Movie Is Nothing Then Exit Sub

    Select Case Index

        Case 0 ' Undo

            QTControl1.Movie.Undo

        Case 2 ' Cut

            QTControl1.Movie.Cut

        Case 3 ' Copy

            QTControl1.Movie.Copy

        Case 4 ' Paste

            QTControl1.Movie.Paste

    End Select

End Sub

Private Sub mnuFile_Click(Index As Integer)

    On Error GoTo ErrorHandler

    Dim filePath

    Select Case Index

        Case 0  ' Open

            filePath = GetFileName()

            If filePath <> "" Then

                QTControl1.URL = filePath

                MovieInfo.SetInfoMovie QTControl1.Movie

            End If

        Case 1  ' Open URL

            Dim movieURL As String

            movieURL = InputBox("Enter a URL:", "URL", "http://www.server.com/ movies/sample.mov")

            If movieURL <> "" Then

                QTControl1.URL = movieURL

                MovieInfo.SetInfoMovie QTControl1.Movie

            End If

        Case 2  ' Close

            QTControl1.URL = ""

            MovieInfo.SetInfoMovie Nothing

        Case 4  'Full Screen

            If QTControl1.URL <> "" Then QTControl1.FullScreen = True

        Case 5  ' Get Info

            MovieInfo.SetInfoMovie QTControl1.Movie

            MovieInfo.Move Me.Left + Me.Width + 200, Me.Top

            MovieInfo.Show

        Case 7  ' Exit

            Unload Me

            End

    End Select

    Exit Sub

ErrorHandler:

    Beep

    Dim errStr As String

    errStr = "Failed with error #" & Hex(Err.Number) & ", " & Err.Description

    MsgBox errStr, vbCritical

End Sub

Private Sub QTControl1_SizeChanged(ByVal Width As Long, ByVal Height As Long)

    ' ignore event if control was resized as a result of form being resized.

    If gManualFormResize Then Exit Sub

   ' resize window to accomodate control

    Me.Move Me.Left, Me.Top, (Width + GetFormBorderWidth()) *  Screen.TwipsPerPixelX, (Height + GetFormBorderHeight()) * Screen.TwipsPerPixelY

End Sub

Private Sub QTControl1_StatusUpdate(ByVal statusCodeType As Long, ByVal statusCode  As Long, ByVal statusMessage As String)

     Select Case statusCodeType

        Case qtStatusCodeTypeControl

            Select Case statusCode

                Case qtStatusFullScreenBegin

                    Me.Hide  ' hide movie window

                Case qtStatusFullScreenEnd

                    QTControl1.SetScale 1  ' set back to a reasonable size

                    Me.Show

        End Select

    End Select

End Sub

Begin VB.Form MovieInfo

   BorderStyle     =   4  'Fixed ToolWindow

   Caption         =   "Movie Info"

   ClientHeight    =   5148

   ClientLeft      =   48

   ClientTop       =   288

   ClientWidth     =   5880

   LinkTopic       =   "Form2"

   MaxButton       =   0   'False

   MinButton       =   0   'False

   ScaleHeight     =   5148

   ScaleWidth      =   5880

   ShowInTaskbar   =   0   'False

   StartUpPosition =   3  'Windows Default

   Begin VB.Frame Frame1

      Height          =   3495

      Left            =   120

      TabIndex        =   2

      Top             =   1560

      Width           =   5655

      Begin VB.Label lblData

         Height          =   3135

         Left            =   1560

         TabIndex        =   4

         Top             =   240

         Width           =   3975

      End

      Begin VB.Label lblCaptions

         Alignment       =   1  'Right Justify

         BeginProperty Font

            Name            =   "MS Sans Serif"

            Size            =   7.8

            Charset         =   0

            Weight          =   700

            Underline       =   0   'False

            Italic          =   0   'False

            Strikethrough   =   0   'False

         EndProperty

         Height          =   3135

         Left            =   120

         TabIndex        =   3

         Top             =   240

         Width           =   1335

      End

   End

   Begin VB.Label lblInfo

      Alignment       =   2  'Center

      BeginProperty Font

         Name            =   "MS Sans Serif"

         Size            =   7.8

         Charset         =   0

         Weight          =   700

         Underline       =   0   'False

         Italic          =   0   'False

         Strikethrough   =   0   'False

      EndProperty

      Height          =   975

      Left            =   120

      TabIndex        =   1

      Top             =   480

      Width           =   5535

   End

   Begin VB.Label lblName

      Alignment       =   2  'Center

      BeginProperty Font

         Name            =   "MS Sans Serif"

         Size            =   9.6

         Charset         =   0

         Weight          =   700

         Underline       =   0   'False

         Italic          =   0   'False

         Strikethrough   =   0   'False

      EndProperty

      Height          =   255

      Left            =   120

      TabIndex        =   0

      Top             =   120

      Width           =   5535

   End

End

Attribute VB_Name = "MovieInfo"

Attribute VB_GlobalNameSpace = False

Attribute VB_Creatable = False

Attribute VB_PredeclaredId = True

Attribute VB_Exposed = False

Option Explicit

Dim gMovie As QTMovie

Private Sub Form_Load()

    DisplayMovieData

End Sub

Sub SetInfoMovie(myMovie As QTMovie)

    Set gMovie = myMovie

    DisplayMovieData

End Sub

Function MovieAnnotation(annoID As Long, mov As QTMovie) As String

    ' Annotation returns an error if asked for an annotation that

    '  does not exist (so you can tell the difference between an

    '  annotation that is missing and one that is set to an empty

    '  string), so we need to be prepared for an exception

    On Error Resume Next

    Dim anno As String

    anno$ = ""   ' value will remain if getting value throws exception

    If Not (mov Is Nothing) Then anno$ = mov.Annotation(annoID)

    MovieAnnotation = anno

End Function

Sub DisplayMovieData()

    Dim dataStr As String

    Dim captionsStr As String

    Dim annoStr As String

    Dim track As QTTrack

    lblName = ""

    lblInfo = ""

    lblCaptions = ""

    lblData = ""

    If gMovie Is Nothing Then Exit Sub

    On Error GoTo ErrorHandler

    lblName = MovieAnnotation(qtAnnotationFullName, gMovie)

    ' get some annotations

    lblInfo = ""

    annoStr = MovieAnnotation(qtAnnotationCopyright, gMovie)

    If Trim(annoStr) <> "" Then lblInfo = lblInfo & annoStr & vbCrLf

    annoStr = MovieAnnotation(qtAnnotationAuthor, gMovie)

    If Trim(annoStr) <> "" Then lblInfo = lblInfo & annoStr & vbCrLf

    annoStr = MovieAnnotation(qtAnnotationComments, gMovie)

    If Trim(annoStr) <> "" Then lblInfo = lblInfo & annoStr & vbCrLf

    annoStr = MovieAnnotation(qtAnnotationDescription, gMovie)

    If Trim(annoStr) <> "" Then lblInfo = lblInfo & annoStr & vbCrLf

    captionsStr = "Source:" & vbCrLf & vbCrLf

    dataStr = Trim(gMovie.URL) & vbCrLf & vbCrLf

    captionsStr = captionsStr & "Size:" & vbCrLf & vbCrLf

    dataStr = dataStr & gMovie.Width & " x " & gMovie.Height & vbCrLf & vbCrLf

    captionsStr = captionsStr & "Duration:" & vbCrLf & vbCrLf

    dataStr = dataStr & gMovie.Duration & vbCrLf & vbCrLf

    For Each track In gMovie.Tracks

        captionsStr = captionsStr & track.DisplayName & ":" & vbCrLf

        dataStr = dataStr & track.Format

        If track.Height > 0 Then

            dataStr = dataStr & ", " & track.Width & " x " & track.Height & vbCrLf

        End If

    Next track

    lblCaptions = captionsStr

    lblData = dataStr

    Exit Sub

ErrorHandler:

    dataStr = dataStr & "Error #" & Hex(Err.Number) & ", " & Err.Description &  vbCrLf

    Resume Next

End Sub

Option Explicit

Dim bFormResized As Boolean

Private Sub Form_Load()

    QTControl1.ErrorHandling = qtErrorHandlingRaiseException

    QTControl1.sizing = qtControlFitsMovie

    Load frmInfo

End Sub

Private Sub Form_Resize()

    Dim sizingMode As QTSizingModeEnum

    Dim resetSizing As Boolean

    bFormResized = True

    ' set the sizing mode to "movie fits control" so the movie will adjust

    '  itself as to the new control size

    sizingMode = QTControl1.sizing

    If sizingMode = qtControlFitsMovie Then

        QTControl1.sizing = qtMovieFitsControl

        resetSizing = True

    Else

        resetSizing = False

    End If

    QTControl1.Move 0, 0, Me.Width - (GetFormBorderWidth() *  Screen.TwipsPerPixelX), Me.Height - (GetFormBorderHeight() *  Screen.TwipsPerPixelY)

    If resetSizing Then QTControl1.sizing = sizingMode

    bFormResized = False

End Sub

Private Sub Form_Unload(Cancel As Integer)

    frmInfo.SetInfoMovie Nothing

    QTControl1.URL = ""

    DoEvents

    End

End Sub

Private Sub mnuEdit_Click(Index As Integer)

    Select Case Index

        Case 0  'Undo

            QTControl1.Movie.Undo

        Case 2  'Cut

            QTControl1.Movie.Cut

        Case 3  'Copy

            QTControl1.Movie.Copy

        Case 4  'Paste

            QTControl1.Movie.Paste

    End Select

End Sub

Private Sub mnuFile_Click(Index As Integer)

    Dim FileName

    Select Case Index

        Case 0  'Open

            ' make the control automatically resize itself whenever the movie

            ' size changes

            QTControl1.sizing = qtControlFitsMovie

            FileName = GetFileName()

            If FileName <> "" Then

                QTControl1.URL = FileName

                If frmInfo.Visible Then

                    frmInfo.SetInfoMovie QTControl1.Movie

                End If

            End If

        Case 1  'Open URL

            QTControl1.sizing = qtControlFitsMovie

            Dim URL$

            URL$ = InputBox("Enter a URL:", "URL", "http://www.server.com/movies/ sample.mov")

            If URL$ <> "" Then

                QTControl1.URL = URL$

                If frmInfo.Visible Then

                    frmInfo.SetInfoMovie QTControl1.Movie

                End If

            End If

        Case 2  'Close

            frmInfo.SetInfoMovie Nothing

            QTControl1.URL = ""

            frmInfo.Hide

        Case 4  'Full Screen

            If QTControl1.URL <> "" Then QTControl1.FullScreen = True

        Case 5  'Get Info

            If QTControl1.URL <> "" Then

                frmInfo.SetInfoMovie QTControl1.Movie

                frmInfo.Move Me.Left + Me.Width + 200, Me.Top

                frmInfo.Show

            End If

        Case 7  'Exit

            Unload Me

            End

    End Select

End Sub

Private Sub QTControl1_SizeChanged(ByVal Width As Long, ByVal Height As Long)

    ' Ignore event if control was resized as a result of form being resized.

    '  avoids race condition

    If bFormResized Then Exit Sub

    'Resize window to accomodate control

    Me.Move Me.Left, Me.Top, (Width + GetFormBorderWidth()) *  Screen.TwipsPerPixelX, (Height + GetFormBorderHeight()) * Screen.TwipsPerPixelY

End Sub

New Abstraction Layer For Audio

QuickTime 7 for Windows introduces the audio context––a new abstraction that represents playing to an audio device.

As defined, a QuickTime audio context is an abstraction for a connection to an audio device. This allows you to work more easily and efficiently with either single or multiple audio devices in your application.

extern OSStatus

QTAudioContextCreateForAudioDevice(

  CFAllocatorRef       allocator,

  CFStringRef          audioDeviceUID,

  CFDictionaryRef      options,

  QTAudioContextRef *  newAudioContextOut);

High-Resolution Audio Support

High-resolution audio makes use of an enhanced sound description with the ability to describe high sampling rates, multiple channels, and more accurate audio representation and reproduction.

Significantly, the new sound description has larger fields to describe the sampling rate and number of channels, so that the sound description is no longer the limiting factor for these characteristics.

The sound description has built-in support for variable-bit-rate (VBR) audio encoding with variable-duration compressed frames. Extensions to the sound description allow you to describe the spatial layout of the channels, such as quadraphonic and 5.1 surround sound, or to label channels as discrete––that is, not tied to a particular geometry. For more information, see “SoundDescriptionV2”.

New movie audio properties include a summary channel layout property, providing a nonredundant listing of all the channel types used in the movie—such as L/R for stereo, or L/R/Ls/Rs/C for 5-channel surround sound—and a device channel layout, listing all the channel types used by the movie’s output device.

Figure 2-2 shows the layout of surround speakers. The terminology is defined in Table 2-1.

The new sound description is supported by the data types and structures found in CoreAudioTypes.h. While the Core Audio API itself is not available to Windows programmers, QuickTime for Windows does include the relevant data structures, such as audio buffers, stream descriptions, and channel layouts defined in CoreAudioTypes.h.

A suite of functions has been included to support the handling of sound descriptions opaquely.

QuickTime Settings Dialogs

QuickTime 7 for Windows introduces a new series of settings dialogs for improved control over audio playback.

QuickTime does not manage a list of devices that is separate from the list available in Windows. If you want to set your input and output devices, you click in the appropriate settings field. In the Sound Out area of the Audio tab in the QuickTime Settings dialog (Figure 2-3), the sound characteristics of the playback device are not changed. If the user specifies 48 kHz, for example, QuickTime will not go to the output device and flip a switch to that setting.

Figure 2-3 illustrates the QuickTime Settings dialog with the Audio tab selected. Thisdialog lets users configure QuickTime to use the proper settings for their audio device. Users can select the output format supported by aparticular audio device, including sample rate, sample size, and number of channels.(You cannot use this dialog to change the settings of the actual output device, only the format that QuickTime sends to the device.)

Figure 2-4 illustrates the various settings that are available for audio, including channel assignment. This information panel in QuickTime Player lets users modify some aspects of a movie’s audio, such as volume, balance, bass, and treble.

Figure 2-5 illustrates the Sound Settings dialog in QuickTime 7 for Windows. This audio compression settings dialog comes up during an export.

Sound Description Creation and Accessor Functions

QuickTime 7 for Windows provides new functions that let you create, access, and convert sound descriptions.

Sound descriptions can take three basic inputs: an AudioStreamBasicDescription, a channel layout, and a magic cookie. Sound descriptions are now treated as if they are opaque. In QuickTime 7, when you are handed a sound description, for example, you don’t have to go in and look at the version field.

If you want to create a sound description, you can simply hand it an AudioStreamBasicDescription, an optional channel layout if you have one, and an optional magic cookie if you need one for the described audio format. Note that it is the format (codec) of the audio that determines whether it needs a magic cookie, not the format of the sound description.

By calling QTSoundDescriptionCreate, you can make a sound description of any version you choose––for example, one that is of the lowest possible version, given that it is stereo and 16-bit, or one of any particular version you want or request.

The main point about the new API is the capability provided to create a sound description and the usage of new property getters and setters. To accomplish this, follow these steps:

1. Get an AudioStreamBasicDescription from a sound description.

2. Get a channel layout from a sound description (if there is one).

3. Get the magic cookie from magic cookie (if there is one).

You can also:

1. Get a user-readable textual description of the format described by the SoundDescription.

2. Add or replace a channel layout to an existing sound description. For example, this is what QuickTime Player does in the properties panel where the user can change the channel assignments.

3. Add a magic cookie to a sound description. (This is not needed very often unless you are writing a movie importer, for example.)

To convert an existing QuickTime sound description into the new V2 sound description, you call QTSoundDescriptionConvert. This lets you convert sound descriptions from one version to another.

For a description of versions 0 and 1 of the SoundDescription record, see the documentation for the QuickTime File Format.

For a description of version 2 of the SoundDescription record, see “SoundDescriptionV2”. For details of the sound description functions, see QTSoundDescriptionCreate and QTSoundDescriptionConvert.

For details on getting and setting sound description properties, see QTSoundDescriptionGetProperty andQTSoundDescriptionSetProperty

Audio Playback Enhancements

In addition to playing back high-resolution audio, QuickTime 7 for Windows introduces the following audio playback enhancements:

• The ability to play movies at a nonstandard rate without pitch-shifting the audio.

• Getting and setting the gain, balance, and mute values for a movie, or the gain and mute values for a track.

• Providing audio level and frequency metering during playback.

Audio Conversion, Export, and Extraction

The new audio extraction API lets you retrieve mixed, uncompressed audio from a movie.

Note that the audio extraction API currently only mixes audio from sound tracks. Other media types, such as muxed MPEG-1 audio inside a program stream, are not currently supported.

To use the audio extraction API, follow these steps:

1. Begin by calling MovieAudioExtractionBegin. This returns an opaque session object that you pass to subsequent extraction routines.

2. You can then get the AudioStreamBasicDescription for the audio or layout. Note that some properties are of variable size, such as the channel layout, depending on the audio format, so getting the information involves a two-step process.

   1. First, you call MovieAudioExtractionGetPropertyInfo to find out how much space to allocate.

   2. Next, call MovieAudioExtractionGetProperty to obtain the actual value of the property.

3. You can use the AudioStreamBasicDescription to specify a different uncompressed format than Float 32. This causes the extraction API to automatically convert from the stored audio format into your specified format.

4. Use the MovieAudioExtractionSetProperty function to specify channel remapping––that is, a different layout––sample rate conversion, and preferred sample size. You can also use this function to specify interleaved samples (default is non-interleaved) or to set the movie time to an arbitrary point.

Note that there are basically two things you set here: an audio stream basic description (ASBD) and a channel layout. (ASBD sets the format, sample, number of channels, interleavings, and so on.)

Setup is now complete. You can now make a series of calls to MovieAudioExtractionFillBuffer to receive uncompressed PCM audio in your chosen format.

1. The default is for the first call to begin extracting audio at the start of the movie, and for subsequent calls to begin where the last call left off, but you can set the extraction point anywhere in the movie timeline by calling MovieAudioExtractionSetProperty and setting the movie time.

2. MovieAudioExtractionFillBuffer will set kMovieAudioExtractionComplete in outFlags when you reach the end of the movie audio.

3. You must call MovieAudioExtractionEnd when you are done. This deallocates internal buffers and data structures that would otherwise continue to use memory and resources.

A caveat: Ideally, the uncompressed samples would be bitwise identical whether you obtained the samples by starting at the beginning of the movie and iterating through it, or by randomly setting the movie time and extracting audio samples. This is typically the case, but for some compression schemes the output of the decompressor depends not only on the compressed sample, but the seed value in the decompressor that remains after previous operations.

The current release of QuickTime does not perform the necessary work to determine what the seed value would be when the movie time is changed prior to extracting audio; while the extracted audio is generally indistinguishable by ear, it may not always be bitwise identical.

For details about audio conversion, export, and extraction, refer to the information about the following functions:

• MovieAudioExtractionBegin

• MovieAudioExtractionGetPropertyInfo

• MovieAudioExtractionGetProperty

• MovieAudioExtractionSetProperty

• MovieAudioExtractionFillBuffer

• MovieAudioExtractionEnd

Standard Audio Compression Enhancements

QuickTime 7 for Windows introduces a new standard compressor component, StandardCompressionSubTypeAudio, that adds the ability to configure high-resolution audio output formats. It has a full set of component properties to make configuration easier, especially when the developer wishes to bring up an application-specific dialog, or no dialog, rather than the typical compression dialog.

This component essentially replaces the StandardCompressionSubTypeSound component, which is limited to 1 or 2 channel sound with sampling rates of 65 kHz or less. That component is retained for backward compatability with existing code, but its use is no longer recommended.

The StandardCompressionSubTypeAudio component is configured by getting and setting component properties, instead of using GetInfo and SetInfo calls. These properties have a class and ID, instead of just a single selector.

The component property API allows configuration at any level of detail without requiring a user interface dialog or direct communication with low-level components.

For details, refer to the section Audio Property Selectors.

If you use MovieExportToDataRefFromProcedures, your getProperty proc will need to support some of these property IDs as new selectors. Note that the Movie Exporter getProperty proc API is not changing to add a class (the class is implied).

Audio Export Enhancements

Some movie export components now support high-resolution audio.

Export of high-resolution audio is transparent at the high level. If you export from a movie containing high-resolution audio to a format whose export component supports it, the transfer of data is automatic; if the export component does not support high-resolution audio, mix-down, resampling, and sound description conversion are automatic.

Export at the lower levels requires some additional code. Your application must “opt in” to the new audio features explicitly if it talks directly to an export component instance. (This is to prevent applications that have inadvisedly chosen to “walk” the opaque atom settings structure from crashing when they encounter the new and radically different structure.) The following code snippet (Listing 2-6) illustrates the opt-in process.

Listing 2-6  Opting in for high-resolution audio export

ComponentInstance exporterCI;

ComponentDescription search = { ’spit’, ’MooV’, ’appl’, 0, 0 };

Boolean useHighResolutionAudio = true, canceled;

OSStatus err = noErr;

Component c = FindNextComponent(NULL, &search);

exporterCI = OpenComponent(c);

// Hey exporter, I understand high-resolution audio!!

(void) QTSetComponentProperty(// disregard error

        exporterCI,

        kQTPropertyClass_MovieExporter,

        kQTMovieExporterPropertyID_EnableHighResolutionAudioFeatures,

        sizeof(Boolean),

        &useHighResolutionAudio);

err = MovieExportDoUserDialog(exporterCI, myMovie, NULL, 0, 0, &canceled);

For additional details, see “Movie Exporter Properties”.

Frame Reordering Video

QuickTime 7 for Windows adds support for frame reordering video compression. This is a major advance that involves new sample tables for video to allow video frames to have independent decode and display times.

The result of using frame reordering for video compression is improved display and editing in H.264 and other advanced video codec formats. Enhancements include a new API for working with media sample times, adding and finding samples, and a new Image Compression Manager (ICM) API.

CFDictionaryRef attributesDictionary = NULL;

err = ICMCompressionSessionGetProperty(

    session,

    kQTPropertyClass_ICMCompressionSession,

    kICMCompressionSessionPropertyID_CompressorPixelBufferAttributes,

    sizeof(CFDictionaryRef),

    &attributesDictionary,

    NULL);

if (attributesDictionary) {

    // ...use...

    CFRelease(attributesDictionary);

}

H.264 Codec

The H.264 codec is the latest standards-based video codec. Published jointly by the ITU as H.264––Advanced Video Coding, and by ISO as MPEG-4 Part 10––Advanced Video Coding, the H.264 codec promises better image quality at lower bit rates than the current MPEG-4 video codec, and also better live streaming characteristics than the current H.263 codec.

This represents a significant increase in quality and performance, while operating in a standards-based framework.

QuickTime 7 for Windows includes a QuickTime decompressor component and an exporter component for creating and playing H.264-encoded video in QuickTime.

The H.264 codec makes use of QuickTime 7’s new support for frame reordering video compression.

Using NewMovieFromProperties

To instantiate a movie using NewMovieFromProperties, follow these steps:

1. Pass in a CFString file path, a URL, or set up a data reference, just as you would for NewMovieFromDataRef or one of the other NewMovieFrom_ functions.

2. Next, set up a visual context for the movie to use by calling a function that creates a context of a the desired type, such as QTOpenGLTextureContextCreate. Similarly, you can set up an audio context if you want a device other than the default device.

3. Call NewMovieFromProperties, passing in the data reference for the movie and the QTVisualContextRef for the visual context, plus any appropriate properties listed in the QTNewMoviePropertyArray.

Properties are passed in using a QTNewMoviePropertyElement struct, which specifies the property class and property ID of each property.

The movie will automatically retain the visual context, so if your application does not need to work with the context directly, you may release it now.

For additional details, see:

• QTNewMoviePropertyArray

• QTNewMoviePropertyElement

• NewMovieFromProperties

How It Works

Metadata is encapsulated in an opaque container and accessed using a QTMetDataRef. A QTMetaDataRef represents a metadata repository consisting of one or more native metadata containers. The QuickTime metadata API supports unified access to and management of these containers.

Each container consists of some number of metadata items. Metadata items correspond to individually labeled values with characteristics such as keys, data types, locale information, and so on. Note that what QuickTime calls items are sometimes referred to as attributes or properties in other metadata systems.

You address each container by its storage format (kQTMetaDataStorageFormat). Initially, there is support for classic QuickTime user data items, iTunes metadata, and a richer QuickTime metadata container format. A QTMetaDataRef may have one or all of these. No direct access to the native storage containers is provided.

QTMetaDataRefs may be associated with a movie, track or media. This parallels user data atoms usage but provides access to other kinds of metadata storage at those levels.

A metadata item is assigned a runtime identifier (QTMetaDataItem) that along with the QTMetaDataRef identifies the particular item (and value) across all native containers managed by the QTMetaDataRef.

Each item is addressed by a key, or label. The key is not necessarily unique within its container, as it is possible to have multiple items with the same key (for example, multiple author items). Functions exist to enumerate all items or only items with a particular key.

Because a QTMetaDataRef may provide access to different native metadata containers with differing key structures—a four-char-code for one, a string for another, and so on—the key structure is also specified. A QTMetaDataKeyFormat indicates the key structure to functions that take keys. This also supports container formats that allow multiple key structures or multiple versions of key structures.

To allow unified access across disparate containers, you can specify a wildcard storage format. This can be used for operations such as searches across container formats. A special key format called kQTMetaDataKeyFormatCommon indicates one of a set of common keys that can be handled by multiple native containers (for example, copyright).

Both modes of operation are illustrated in Figure 2-6.

Advantages of the New Metadata Format

The QuickTime metadata format is inherently extensible. Instead of a set of structures and enumerated parameters, the metadata API uses a set of properties that can be enumerated, and whose characteristics can be discovered, dynamically at runtime. This is analogous to the QuickTime component property function in that you first get the property info, such as its size and format, and then you allocate the appropriate container or structure to get or set the actual property.

The new QuickTime metadata format and API consist of the following structures, enumerations, and functions, grouped in sections followed by the specific functions:

• “Metadata Format Constants”

• “Metadata Property IDs”

• “Metadata Key Constants”

• “Metadata Error Codes”

• QTCopyMovieMetaData

• QTCopyTrackMetaData

• QTCopyMediaMetaData

• QTMetaDataAddItem

• QTMetaDataGetItemCountWithKey

• QTMetaDataGetItemProperty

• QTMetaDataGetItemPropertyInfo

• QTMetaDataGetItemValue

• QTMetaDataGetNextItem

• QTMetaDataGetProperty

• QTMetaDataGetPropertyInfo

• QTMetaDataRetain

• QTMetaDataRelease

• QTMetaDataRemoveItem

• QTMetaDataRemoveItemsWithKey

• QTMetaDataSetItem

• QTMetaDataSetItemProperty

• QTMetaDataSetProperty

New Install Location

Beginning with QuickTime 7 for Windows, the default install location for QuickTime has been moved from the directory:

\Windows\System32\QuickTime

to

\Program Files\QuickTime

Optionally, the user may specify a custom install location when performing the installation.

The QuickTime installer will also create a number of subdirectories within the QuickTime directory where the various QuickTime files are stored. For example, a QuickTime System directory QTSystem is created as follows:

\QuickTime\QTSystem

to store the various QuickTime system files.

Updates to QuickTime for Java

QuickTime for Java (QTJ) is now fully supported in QuickTime 7 for Windows. QTJ is now installed by default in QuickTime 7.

This release includes a number of important bug fixes requested by QuickTime for Java developers. These are as follows:

• Major fixes for issues related to drawing and correct QTComponent rendering

• Compatibility with headless applications

• Fixes for issues related to movie progress procedures and movie exporting

• Fixes for Applet issues, including support for MPEG video playback in an applet

• Support for 2-byte character file names

• Security fixes