Adobe After Effects 5 5 Manual
Adobe After Effects 5.5, size: 10.1 MB
By Jaysehansen - Virtual Training Company (2003) - Book - ISBN 1930519427
Here you can find all about Adobe After Effects 5 5, for example manual and , free download, download, system requirements, torrent, tutorial. You can also write a review. [ Report abuse or wrong photo | Share your Adobe After Effects 5 5 photo ]
User reviews and opinions
|daniel_ccna||10:43pm on Sunday, October 31st, 2010|
|The Gold Standard For Desktop Video Manipulation The amount of thought that has gone into After-Effects is astounding. It is, at once.|
|ZCB||7:36pm on Sunday, July 11th, 2010|
|The Gold Standard For Desktop Video Manipulation The amount of thought that has gone into After-Effects is astounding. It is, at once. The Gold Standard For Desktop Video Manipulation The amount of thought that has gone into After-Effects is astounding. It is, at once.|
|bodells||7:42pm on Friday, March 19th, 2010|
|The Gold Standard For Desktop Video Manipulation The amount of thought that has gone into After-Effects is astounding. It is, at once.|
|Robert11||7:04am on Tuesday, March 16th, 2010|
|The Sims started off a new phenomenon when it first appeared on the PC scene back in the year 2000.|
Comments posted on www.ps2netdrivers.net are solely the views and opinions of the people posting them and do not necessarily reflect the views or opinions of us.
Software Development Kit
Adobe After Effects 5.5 Software Development Kit. Copyright 19922002 Adobe Systems Incorporated. All rights reserved. The information in this document is furnished for informational use only, is subject to change without notice, and should not be construed as a commitment by Adobe Systems Incorporated. Adobe Systems Incorporated assumes no responsibility or liability for any errors or inaccuracies that may appear in this document. The software described in this document is furnished under license and may only be used or copied in accordance with the terms of such license. Adobe, Adobe After Effects, Adobe Premiere, Adobe Photoshop, Adobe Illustrator, Adobe Type Manager, ATM and PostScript are trademarks of Adobe Systems Incorporated that may be registered in certain jurisdictions. Macintosh and Apple are registered trademarks, and Mac OS are trademarks of Apple Computer, Inc. Microsoft, Excel, and Windows are registered trademarks of Microsoft Corporation. All other products or name brands are trademarks of their respective holders. The material in this document is supplied by the After Effects Engineering team, as collected and presented by Bruce Bullis. Version History
January 1993 January 1994 August March June Nov. April May January 1999 Russell Belfer Dan Wilk Dave Herbstman Dan Wilk Brian Andrews Brian Andrews Brian Andrews Brian Andrews Bruce Bullis Bruce Bullis Version 1.0 Initial SDK release. Version 2.0 Updates. Version 2.0.1 Added support for PowerPC. Version 3.0 Preliminary release for the After Effects developer kitchen. Version 3.1 Final 3.x release. Version 3.1 SDK Release 2 Minor updates. Version 3.1 SDK Release 3 First public release (really a pre-release) of the SDK for Windows development. Version 3.1 SDK Release 6 - Editorial changes only Version 4.0 SDK Release 1 - Added information on new global ags, custom data types, utilization of PICA suites, CustomUI messaging and parameter supervision, new callbacks. many editorial changes. Revised for 4.1; added General plug-ins and AEGP information. Added information on new selectors, resize handle.
9 September 1999
Adobe After Effects SDK
2 February 2001 Bruce Bullis Initial 5.0 release. Entire document edited and reformatted. Sections on 16bit-per-channel color and parameter supervision, as well as the entire AEGP chapter, have all substantially expanded. Initial 5.5 release. Added information on new outags, PiPL changes, and additions and changes to the AEGP API. Numerous clarications and edits. Updated MacOS X details.
1 December 2001
9 January 2002
About this document
The Introduction explains what plug-ins are, and how After Effects communicates with them. The Overview describes attributes common to all effect plug-ins; where theyre located, how theyre invoked, and the commands they receive. Parameters are thoroughly discussed in chapter 3. Chapter 4 dives into the details of modifying pixels. The structures passed to (and from) effects are detailed here, as well as the many provided callback functions. Chapter 5 covers events sent to effect plug-ins, how to incorporate custom user interface elements, parameter supervision, and the reliance of custom data parameter types on Custom UI messaging. Audio effects are covered in Chapter 6. Chapter 7 provides an overview of the After Effects General Plug-in (AEGP) API, provided callback functions, how to intercept After Effects internal messages, obtain the current contents of the composition window, and adding menu commands are all covered at length. Artisans, Keyframers, and File IO AEGPs are all covered.
Functions, structure names and general C/C++ code are in Courier; MyStruct and MyFunction(); Text in blue is hyperlinked. Command selectors are italicized; PF_Cmd_RENDER.
This document covers the design and theory behind the APIs, and serves as a companion to the sample projects, which exercise the APIs. The HTML documentation details the sample projects themselves, and any latebreaking issues. Almost every change to the API is suggested by developers like you. Talk to us! Questions regarding installation, configuration and use of Adobe products go to Adobe Technical Support, not to API Engineering. In this documentation, we try to be specific and thorough, yet conversational. Let us know how were doing. Weve worked hard on making the SDK a pleasure to use, and we welcome your comments and feedback.
The After Effects team thanks you, our developers, for all your hard work. And we congratulate you on your incredible results! You are the driving force behind the improvement and expansion of the API(s) and SDK; your products enable After Effects to do things wed never even considered. You make After Effects better through your efforts; keep it up!
About this document. 3 Organization. 3 Documentation Conventions. 4 SDK Philosophy. 4 Developers matter!. 4
Chapter 1: Introduction..15
Whats new in 5.5?. 15 API. 15 OS X and Carbon. 15 PiPLs. 15 What was new in 5.0. 16 16-bit-per-channel color. 16 Improved messaging. 16 Access to camera and light data. 16 AEGPs. 16 Artisans. 16 Keyframers. 17 AEIO. 17 Should I update my plug-ins for 5.5?. 17 Function Suites Galore. 17 PICA Suites : good, and good for you. 18 SDK Audience. 18 C++. 18 The development process. 19 Designing plug-ins. 19 Creating plug-ins. 20
Chapter 2: Overview..21
What plug-ins are. 21.according to the OS. 21
.according to After Effects. 21 System Requirements. 21 PiPLs. 21 OS X. 22 Different code for MacOS 9.x and X in the same plug-in. 22 Multiple PiPLs. 23 API Specification Version. 23 Entry Point. 23 Where plug-ins are. 23 Where plug-ins appear within After Effects. 24 Localization. 24 What plug-ins do. 24 Debugging plug-ins. 25 How After Effects communicates with plug-ins. 25 Entry point. 25 Table 1: Plug-in entry point 26 Command Selectors. 27 Table 2: Command Selectors. 27 PF_InData. 31 Table 3: PF_InData Structure. 31 Why is After Effects telling me all this?. 34 PF_OutData. 35 Table 4: PF_OutData Structure. 35 PF_OutFlags. 36 Table 5: PF_OutFlags. 36 PF_Outflags2. 39 Table 6: PF_OutFlags2. 40 Parameters. 40 Extra. 40 Error Codes. 40 Table 7: Error Codes. 41
Basic calling sequence. 41 Error Reporting. 42 Turning Pro. 42 Non-square pixels. 42 Non-uniform downsampling. 42 Parameter ordering and versioning. 42 Point controls and buffer expansion. 43 Output at non-integral frame times. 43 Output when time remapped. 43 Motion blur and shutter angle. 43 Caching behavior. 44 Dynamic flags. 44 Rowbytes in PF_Worlds; believe us. 44 Summary. 44
Chapter 3: Parameters...45
Table 8: Parameter Types. 45 PF_ParamDef. 47 Table 9: PF_ParamDef. 47 Parameter Flags. 48 Table 10: Parameter Flags. 48 Parameter UI Flags. 49 Table 11: Parameter UI Flags. 49 Layers. 50 Table 12: PF_LayerDef structure. 50 Layer checkout behavior. 50 New in 5.5. 51 Arbitrary data types. 51 I am not a number!. 51 Table 13: Arbitrary data selectors. 51
Arbitrary data requires re-entrancy. 52 Special parameter types. 53 Accessing path data. 53 Accessing camera and light information. 53 Implementing arbitrary data. 53 Lock it. 54 Parameter Supervision. 55 Updating parameter interfaces. 55 Beauty is only UI deep. 55 Parameter Implementation. 55 Dont cache me. 55 Big time. 56 Range issues. 56 Whats the difference?. 56 Downsampling. 56 Rate x Time == PAIN. 56 Wash before first use. 57 Changing parameter orders, the nice way. 57
Chapter 4: Rendering..58
Free code == GOOD. 58 PICA Suites. bit-per-channel color. 59 Parameter checkout behavior. 59 PICA. 59 Versioning. 59 Why bother?. 59 Adobe Dialog Manager. 60 Exceptions. 60 Make sure that all exceptions are handled by your plug-in; After Effects APIs are designed for plug-ins written in C, dont expect exceptions, and will close
After Effects immediately should they encounter one. 60 own which have not. 62 Memory. 62 Handles. 62 Different Scopes. 62 Flattened and Unflattened. 62 Not now, honey. 63 Callback Functions. 64 Parameter Callbacks. 64 Table 14: Interaction Callbacks. 64 Kernel Flags. 66 Table 15: Kernel Flags. 67 Graphics utility callbacks. 68 Transform Worlds. 68 Table 16: PF_WorldTransformSuite. 68 Fill em up. 70 Table 17: FillMatteSuite Functions. 70 Table 18: PF_SamplingSuite Functions. 71 Try a sample!. 73 Table 19: PF_BatchSamplingSuite. 73 Accessor macros for opaque (data type) pixels. 73 Table 20: PF_PixelPtr accessor macros. 74 Math functions. 74 Table 21: PF_ANSICallbacksSuite. 75 ANSI Callbacks. 76 Table 22: ANSISuite. 76 Why not just use strcpy()?. 76 Colorspace Conversion. 76 Table 23: Pixel Types for different colorspaces 76 Colorspace conversion. 77 Table 24: PF_ColorCallbacksSuite 77 Memory allocation. 77
Table 25: PF_HandleSuite. 78 PF_World allocation functions. 78 Table 26: PF_WorldSuite. 78 Iteration Suites. 79 Table 27: PF_IterateSuite. 79 Time Terminology. 81 New Worlds. 82 Parameter checkout behavior with motion blurred plug-ins. 82 Source pixels. 82 Fields. 82 Pixels? Deep. 82 But I just need a couple of bytes. 83 Usability. 83
Chapter 5: UI and Events..84
Table 28: Events. 84 More information. 85 Table 29: PF_EventExtra structure. 85 PF_Context. 87 Table 30: PF_Context structure. 87 Table 31: PF_EffectWindowInfo structure. 87 Event Details. 88 Click. 88 Table 32: PF_DoClickEventInfo structure. 88 Draw. 88 Table 33: PF_DrawEventInfo structure. 88 Keydown. 89 Table 34: PF_KeyDownEventInfo structure. 89 AdjustCursor. 89 Table 35: PF_AdjustCursorEventInfo structure. 89 Arbitrary Parameters Event. 90 Table 36: PF_ArbParamsExtra structure. 90
How should I draw that?. 164 Transform Conventions. 164 Table 65: Artisan Query Transform Suite. 165 Pushing Pixels. 166 Table 66: Artisan Composite Suite. 166 Do This Many Times. 168 Table 67: Artisan Iterate Suite. 168 AEIO AEGPs. 168 What can these plug-ins do?. 169 How they do it. 169 What would After Effects do?. 169 Behavior Flags. 170 Table 68: AEIO_FunctionBlock. 170 What Goes In. 178 Table 69: AEIO AEGPIOInSuite. 179 What Goes Out. 183 Table 70: AEIO AEGPIOOutSuite. 183 File Import Manager suite. 187 Table 71: (AEGP_FIMSuite2) File Import Manager Suite. 188 Keyframes and the Framers who Key Them. 189 Table 72: Keyframe Suite. 189 AEGP Details. 192 Effect usage of AEGP Suites. 192 Names and Solids. 193 Whats the difference; theyre all pixels, right?. 193 Linkage. 193 Reporting errors and problems. 193 Transforms: what happens first?. 193 Tracked Memory. 194
Welcome to the Adobe After Effects 5.5 Software Development Kit! This is a living document, and is constantly being updated and edited. The latest public version of the SDK will be made available from: http://partners.adobe.com/asn/developer/gapsdk/AfterEffectsSDK.html
Whats new in 5.5?
There have been relatively few changes to After Effects APIs for 5.5; this is a good thing! Weve filled in some gaps in the AEGP API, including the ability to create camera and lighting layers, and added the ability to pass time parameters in composition or layer space, as appropriate. Weve also
OS X and Carbon
Metrowerks CodeWarrior version 7.1 is required for debugging plug-ins under MacOS X. The MacOS samples have been Carbonized, and run natively in OS X. The samples which use QuickDraw still rely on MacHeadersPPC. Any OS X-specific issues will be noted in the implementation details at the end of each chapter. Please refer to Apple Developer documentation for any assistance with Carbon, OS X, or other porting issues.
For those of you who use C++ and simply must keep your plug-ins loaded all the time, check the samples for a special bit in the AE_Reserved_Info fields
pre_effect_ source_origin_x pre_effect_ source_origin_y
Origin of the source image in the input buffer. Valid only when sent with a frame selector. Non-zero only if one or more effects that preceded this effect on the same layer resized the output buffer and moved the origin. Check for both the resize and the new origin to determine output area. This is useful for effects which have implicit spatial operations (other than point controls), like ipping a le around an images center. NOTE: Checked-out point parameters are adjusted for the preeffect origin at the current time, not the time being checked out.
Offset from frame time to shutter open time as a percentage of a frame.
Why is After Effects telling me all this?
After Effects gives plug-ins a lot of information; take advantage! Lets explore an implementation of extent_hint (the smallest rectangle enclosing the area for which output is required). Tell After Effects you use in_data->extent_hint by setting PF_OutFlag_USE_OUTPUT_EXTENT in PF_OutData during PF_Cmd_GLOBAL_SETUP. Disable the image cache from Edit > Preferences > Cache before testing extent hint code, so After Effects renders your effect whenever anything in your composition changes. Otherwise, the caching mechanism would obscure your plug-ins (possibly incorrect) output. Move the layer within the comp so its cropped. The output->extent_hint is the portion of the layer which is visible in the composition. Add a mask to your layer and move it around. This changes the extent_hint, which encloses all of the non-zero alpha areas of the image.The in_data>extent_hint is the intersection of these two rectangles (the comp and the mask), and changes whenever they do. Extent rectangles are computed in the coordinate space of the original input layer, before its resizing and origin shifting. Account for downsampling when computing output size users must be able to render at full resolution. If the output buffer exceeds 30000 by 30000, clamp it to that size, and consider displaying an alert dialog.
Once your code behaves correctly, enable the cache and see how frequently the effect needs to re-render. Consider a Drop Shadow; users frequently apply a static drop shadow to a still image. The output extent_hint is ignored, so the cache is used more often.
Communicate changes to After Effects using PF_OutData. Valid times for altering these fields are noted. Table 4: PF_OutData Structure Field
Set this flag (using the PF_VERSION macro) to the version of your plug-in code. After Effects uses this data to decide which of duplicate effects to load. Copy your plug-ins name here. After Effects checks this after PF_Cmd_GLOBAL_SETUP. Handle which will be returned to you in PF_InData with every call. Use After Effects memory allocation functions. After Effects checks this field against the number of calls made to PF_ADD_PARAM, as well as the implicit input layer. Allocatable upon receiving PF_Cmd_SEQUENCE_SETUP, this handle will be passed back to you in PF_InData during all subsequent calls.See the Overview. Unused (After Effects knows the size, because you used its allocation functions to get the memory in the rst place). Handle you (might have) allocated during PF_Cmd_FRAME_SETUP. This is never written to disk; it was used to pass information from your PF_Cmd_FRAME_SETUP response to your PF_Cmd_RENDER or PF_Cmd_FRAME_SETDOWN (which you must do if you resize the output buffer). Otherwise, this memory is rarely used. Set during PF_Cmd_FRAME_SETUP if the output image size differs from the input. width and height are the size of the output buffer, and origin is the point the input should map to in the output. To create a 5-pixel drop shadow up and left, set origin to (5, 5). Send messages to After Effects. OR together multiple values. After Effects displays any C string you put here (checked and cleared after every command selector).
If you check out parameter values at other times, or use layer parameters at all, you must check in those parameters when finished, even if an error has occurred. Remember, checked-out parameters are read-only.
Wash before first use
Failing to completely clear out a PF_ParamDef prior to PF_ADD_PARAM() can cause many problems. Always use the AEFX_CLR_STRUCT macro before adding parameters.
Changing parameter orders, the nice way
It is possible to add or remove parameters from a plug-in, without forcing users to re-apply all instances of that plug-in to use the updated version. However, some advance planning on your part is necessary to allow for such changes. Your users (and technical support staff) will appreciate the effort. You must first create a parameter array index. During PF_Cmd_PARAM_SETUP, assign index values to each parameter as you add them, using a simple enumeration. The order of enumeration corresponds to the order in which the parameters are registered during PF_Cmd_PARAM_SETUP, which in turn determines the order in which they appear in the Effect Control and Time Layout windows. Create another enumeration for disk IDs. The order of this enumeration must not be changed, though you may add to the end of this list. Note that the order of this list need not correspond with that of the parameter array index. Parameter disk IDs should range from 1 to 999. Before calling PF_ADD_PARAM(), specify the disk ID in the PF_ParamDef.uu.id field. If no value is specified, After Effects makes parameters sequential starting with 1. The parameters information is tagged with this ID when saved. In this way, After Effects can still understand that, although your "Foobarocity" slider is now the fourth parameter passed, its the same parameter as when it was second. To delete a parameter without forcing re-application, remove the code which creates it and its entry in the parameter array index list. However, do not remove its entry in the disk ID list. To add a new parameter, add an entry in the appropriate location in the parameter array indices list, add the parameter creation code, and append the disk ID to the end of the disk ID enumeration. To re-order, change the parameter array index list and reorder the parameter creation code appropriately.
Now that you understand what effect plug-ins are and how they interact with After Effects, its time to start modifying pixels. After Effects exposes a tremendous amount of its internal functionality via PICA suites and callback functions.
Free code == GOOD
After Effects provides effect plug-ins with as much information and supporting code as possible. Use our callbacks and function suites to obtain the value of parameters (including source footage) at different times. Use our memory allocation functions to avoid competing with the host for resources, and context problems. Use After Effects to copy, fill, blend and convolve images, and convert between colorspaces. Obtain information about the masks applied to a layer. ANSI emulation and math utility functions are also provided, as well as information about the application, user, serial number, and current drawing context. Using our functions keeps your plug-in compact; you write and test less code. The callbacks are tested, optimized, and used by our own plug-ins. The callbacks are distributed to multiple processors and take advantage of any available hardware acceleration. No, really, use the provided functions.
Plug-ins shipped with After Effects use offscreen (double-buffered) drawing; we recommend you do the same. Use OS-provided drawing tools to draw your UI. The drawing utilities included with the SDK are not intended to be production code.
An arbitrary data parameter is an excellent way to manage your custom UI. Store state, preference, and last-item-used information in an arb, and youll always be able to recover it. After Effects manages parameters with a much richer message stream than custom UIs.
Custom UI implementation for color sampling, using keyframes
A plug-in may want to get a color from a layer within a composition; the user would use the eyedropper associated with a color parameter, or the plug-ins custom composition window UI, to select the point. During the click event, the plug-in converts the coordinates of the click into layer space, and stores that information in sequence data. It then forces a re-render, during which it has access to the color of the layer point corresponding to the stored coordinates. The plug-in stores the color value in sequence data, and cancels the render, requesting a redraw of the affected parameter(s). Finally, during the draw, the plug-in adds appropriate keyframes to its color parameter stream using the KeyframeSuite.
After Effects can process audio encoded at up to 96Khz, floating point (24bit) resolution, mono or stereo. We provide high quality resampling. PF_InData and PF_OutData both contain information specific to audio handling.
All audio effects must set either PF_OutFlag_AUDIO_EFFECT_TOO or PF_OutFlag_AUDIO_EFFECT_ONLY. PF_OutFlag_I_USE_AUDIO is for visual effects that check out audio data, but dont modify it. PF_OutFlag_AUDIO_FLOAT_ONLY, PF_OutFlag_AUDIO_IIR and PF_OutFlag_I_SYNTHESIZE_AUDIO provide greater control over audio output (see PF_OutFlags for more details).
Audio Data Structures
The following data types are used by After Effects to describe audio data. Table 38: Audio data structures Structure
Indicates whether the audio is in unsigned pulse code modulation (PCM), signed PCM, or oating point format. Samples are in 1, 2, or 4 byte format.
Table 38: Audio data structures Structure
Indicates whether the audio is mono or stereo. Contains the sampling rate, number of channels, sample size, and format of the audio to which it refers. Use PF_SoundWorlds to represent audio. In addition to a PF_SoundFormatInfo, they contain the length of the audio, and a pointer to the actual audio data.
PF_SoundFormat, PF_SoundSampleSize, and PF_SoundChannels are all contained within a PF_SoundFormatInfo. PF_SoundWorlds contain a PF_SoundFormatInfo, and further instance-specific information.
Audio filters encounter different issues than do image filters. Investigate the SDK sample for one possible implementation of audio rendering.
The AEGP API
The After Effects General Plug-in (AEGP) API is a powerful and broad API, offering functionality beyond what is available to effect plug-ins. To users, AEGPs are part of After Effects. AEGPs can add, intercept, and trigger menu commands, access the keyframe database, and register functions as part of After Effects internal messaging. AEGPs can add and remove items to projects and compositions, add and remove filters and keyframes. Once its command is triggered, AEGPs use the numerous PICA function suites (described in this chapter) to work with every After Effects item. AEGPs can publish function suites for plug-ins, manipulate all project elements, change interpretations, replace files and determine which external files are used to render a project.
In contrast to the vast expansion which occurred during 5.0, weve made limited additions to the function suites, and some subtle enhancements to existing functions. Many functions which require a time component can now accept either composition time or layer time, and act appropriately.
AEGPs use PICA (Plug-In Component Architecture) suites for all functionality. They may also publish PICA function suites; since plug-in load order can vary, AEGPs must not depend on the presence of a suite not provided by After
Effects. They may request a suite and, if its not present, provide it themselves.
AEGP communication with After Effects
For effect plug-ins, all communication with After Effects occurs through a single entry point function. This is not the case with AEGPs. While After Effects does call the entry point function designated in the AEGPs PiPL (which is still required), the bulk of the communication between After Effects and AEGPs is handled by the hook functions the AEGP registers. This registration must be performed from within the plug-ins entry function, using the RegisterSuite.
Different tasks, same API
AEGPs work in the same manner, regardless of specialization. They can be simple, just adding one menu item to trigger an external application, or complex like Artisans.
We know good developers like you wouldnt write a line of code without a solid, well-tested, and thoroughly-researched functional specification. Spend time learning your potential customers workflows. Does your AEGP help or hinder them in their daily tasks? Are there things you could do with the API that would help them? We think so.
Because the functionality available through the AEGP API is so vast, and the integration with After Effects so deep, a great deal of design work is necessary to ensure that your plug-in behaves appropriately in all situations. AEGPs do everything through PICA function suites. AEGPs are not loaded in a specific order. Check the version of the AEGP API (from within your AEGPs entry point function) to confirm whether a given suite will be available. AEGPs may also use any effect API suite function which doesnt require a PF_ProgPtr (obtained by effects from PF_InData).
Frees an AEGP_SoundDataH. AEGP_DisposeSoundData( AEGP_SoundDataH sound_dataH);
Obtains information about the format of a given AEGP_SoundDataH. AEGP_GetSoundDataFormat( AEGP_SoundDataH soundH, AEGP_SoundDataFormat *formatP);
Locks the AEGP_SoundDataH in memory. AEGP_LockSoundDataSamples( AEGP_SoundDataH soundH, void **samples);
Unlocks an AEGP_SoundDataH. AEGP_UnlockSoundDataSamples( AEGP_SoundDataH soundH);
Obtains the number of samples in the given AEGP_SoundDataH. AEGP_GetNumSamples( AEGP_SoundDataH A_long soundH, *numsamplesPL);
AEGP_LayerSuite provides information about layers within a composition, and the relationship(s) between the source and layer times. As most After
Effects usage boils down to layer manipulation, this is among the largest function suites in our API. Table 45: Layer Suite AEGP_LayerSuite1
AEGP_GetCompNumLayers Obtains the number of layers in a composition. AEGP_GetCompNumLayers( AEGP_CompH compH, A_long *num_layersPL); AEGP_GetCompLayerByIndex Get a LayerH from a composition. Zero is the foremost layer. AEGP_GetCompLayerByIndex( AEGP_CompH comp H, A_long layer_indexL, AEGP_LayerH *layerPH); AEGP_GetActiveLayer Get the active layer. If a Layer or Effects Controls Window is active, the active layer is that associated with the front-most tab in the window. If a Comp or Timeline window is active, the active layer is the selected layer (if only one is selected). AEGP_GetActiveLayer( AEGP_LayerH *layerPH); AEGP_GetLayerIndex Get the index of the layer (0 is the topmost layer in the composition). AEGP_GetLayerIndex( AEGP_LayerH layerH, A_long *layer_indexPL); AEGP_GetLayerSourceItem Get the AEGP_ItemH of the layers source item. AEGP_GetLayerSourceItem( AEGP_LayerH layerH, AEGP_ItemH *source_itemPH); AEGP_GetLayerParentComp Get the AEGP_CompH of the composition containing the layer. AEGP_GetLayerParentComp( AEGP_LayerH layerH, AEGP_CompH *compPH); AEGP_GetLayerName Get the name of a layer. Layer name length up to AEGP_MAX_LAYER_NAME_LEN + 1. AEGP_GetLayerName( AEGP_LayerH layerH, A_char *layer_nameZ0, A_char *source_nameZ0);
Since a layer can have multiple masks, access the masks using AEGP_GetLayerMaskByIndex. Masks dont have streams like layers do; they get their own enumeration. Access their streams using AEGP_GetNewMaskStream.
They can have a variable number of streams/parameters, and the order and definition of them is not known when the AEGP is written. Therefore we cannot offer an enum for selecting them, and instead you must get them by index, hence GetNewEffectStreamByIndex.
Accessing stream values
A stream, once acquired, represents a value which may change over time. Not all streams can vary over time, and a particular stream may not be timevariant at the time of access. There are two ways to access the value of a stream. If the stream has keyframes, you can use the keyframe suite. The values provided wont reflect the influence of expressions. You can also use AEGP_GetNewStreamValue, which samples the value of the stream at a particular time. For streams without expressions or keyframes, the time parameter is meaningless, and the function returns what essentially is the constant value of the stream. Use AEGP_SetStreamValue (which doesn't take a time as a parameter) to set these streams.
Communication with a layers effects
Access the effects applied to a layer. This suite provides access to all parameter data streams. Use the StreamSuite to work with those streams. An AEGP_Effect_RefH is a reference to an applied effect. an AEGP_InstalledEffectKey is a reference to an installed effect, which may or may not be currently applied to anything. If Foobarocity is applied to a layer twice, there will be two distinct AEGP_Effect_RefHs, but theyll both return the same AEGP_InstalledEffectKey. Table 47: Effect Suite AEGP_EffectSuite_1
AEGP_GetLayerNumEffects Get number of effects applied to a layer. AEGP_GetLayerNumEffects( AEGP_LayerH layerH, A_long *num_effectsPL); AEGP_GetLayerEffectByIndex Retrieves (by index) a reference to an effect applied to the layer. AEGP_GetLayerEffectByIndex( AEGP_PluginID aegp_plugin_id, AEGP_LayerH layerH, AEGP_EffectIndex effect_indexL, AEGP_EffectRefH *effectPH);
Table 47: Effect Suite AEGP_EffectSuite_1
AEGP_GetInstalledKeyFromLayerE ffect Given an AEGP_EffectRefH, retrieves its associated AEGP_InstalledEffectKey. AEGP_GetInstalledKeyFromLayerEffect( AEGP_EffectRefH effect_refH, AEGP_InstalledEffectKey *keyP); AEGPD_GetEffectIndParamUnion Returns description of effect parameter. Do not use the value(s) in the ParamDef returned by this function (Use AEGP_GetNewStreamValue() instead); its provided so AEGPs can access parameter defaults, checkbox names, and pop-up strings. Use AEGP_GetEffectNumParamStreams() from the StreamSuite to get the stream count, useful for determining the maximum param_index. The last parameter is optional; AEGPD_GetEffectIndParamUnion( AEGP_PluginID aegp_plugin_id, AEGP_EffectRefH effectH, PF_ParamIndex param_index, PF_ParamType *param_typeP PF_ParamDefUnion *uP0); AEGP_GetEffectFlags Obtains the ags for the given AEGP_EffectRefH. AEGP_GetEffectFlags( AEGP_EffectRefH effect_refH, AEGP_EffectFlags *effect_flagsP); Flags will be a combination of the following: AEGP_EffectFlags_NONE AEGP_EffectFlags_ACTIVE AEGP_EffectFlags_AUDIO_ONLY AEGP_EffectFlags_AUDIO_TOO AEGP_SetEffectFlags Sets the ags (enumerated above) for the given AEGP_EffectRefH, masked by a different set of effect ags. AEGP_SetEffectFlags( AEGP_EffectRefHeffect_refH, AEGP_EffectFlagseffect_flags_set_mask, AEGP_EffectFlagseffect_flags);
Each After Effects project has an associated Blob of persistent data. AEGPs may add and manage their own persistent data using the following suite. For data types not represented by the simple data types provided, use data handles containing your custom data. However, keep in mind that users will expect your data to work on MacOS and Windows. If the project containing your persistent data is opened in a copy of After Effects without your AEGP loaded, the user will not be notified (and will receive no error). Table 54: Persistent Data Suite Function
Obtains the handle to all persistent application data. AEGP_GetApplicationBlob( AEGP_PersistentBlobH *blobPH);
Obtains the number of sections in the application blob. AEGP_GetNumSections( AEGP_PersistentBlobH blobH, A_long *num_sectionPL);
Obtains the key at the given index. AEGP_GetSectionKeyByIndex( AEGP_PersistentBlobHblobH, A_long section_index, A_long max_sctn_size, A_char *section_keyZ);
Retuerns whether or not a given key/value pair exists with the blob. AEGP_DoesKeyExist( AEGP_PersistentBlobHblobH, const A_char *section_keyZ, const A_char *value_keyZ, A_Boolean *existsPB);
Retrieves the number of value keys in the section. AEGP_GetNumKeys( AEGP_PersistentBlobHblobH, const A_char *section_keyZ, A_long *num_keysPL);
Table 54: Persistent Data Suite Function
Retrieves the value of the indexd key. AEGP_GetValueKeyByIndex( AEGP_PersistentBlobH blobH, const A_char *section_keyZ, A_long key_index, A_long max_key_size, A_char *value_keyZ);
For the entry points below, if a given key is not found, a default value is both written to the blob and returned as the value; if no default is provided, a blank value will be written and returned. AEGP_GetDataHandle Obtains the value associated with the given sections key. If using in-memory data structures, watch for end-ian issues. AEGP_GetDataHandle( AEGP_PluginID plugin_id, AEGP_PersistentBlobHblobH, const A_char *section_keyZ, const A_char *value_keyZ, AEGP_MemHandle defaultH0, AEGP_MemHandle *valuePH); AEGP_GetData Obtains the data located at a given sections value. AEGP_GetData( AEGP_PersistentBlobHblobH, const A_char *section_keyZ, const A_char *value_keyZ, A_u_long data_sizeLu, const void *defaultPV0, void *bufPV); AEGP_GetString Obtains the string for a given section keys value (and indicates its length in actual_szLu0). AEGP_GetString( AEGP_PersistentBlobHblobH, const A_char *section_keyZ, const A_char *value_keyZ, const A_char *defaultZ0, A_u_long buf_sizeLu, char *bufZ, A_u_long *actual_szLu0);
For the given AEIO_InSpecH, return a attened version of the data contained in its options handle. Obtain the unattened options handle using AEGP_GetInSpecOptionsHandle AEIO_FlattenOptions( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, AEIO_Handle *flat_optionsPH);
For the given AEIO_InSpecH, create (using AEGP_SetInSpecOptionsHandle) an unattened version of its attened option data. AEIO_InflateOptions( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, AEIO_Handle flat_optionsH);
Table 68: AEIO_FunctionBlock Function
AEIO_Err_USE_DFLT_CALLBACK allowed. Inspect the AEIO_InSpecH, update its options if necessary), and indicate whether or not you made changes. AEIO_SynchInSpec( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, A_Boolean *changed0);
AEIO_Err_USE_DFLT_CALLBACK allowed. Populate the provided A_LRect with the active extent of the les pixels at the given time. AEIO_GetActiveExtent( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, const A_Time *tr, A_LRect *extent); Provide a textual description of the AEIO_InSpecH in the provided AEIO_Verbiage. AEIO_GetInSpecInfo( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, AEIO_Verbiage *verbiageP);
Draw a preview frame from the AEIO_InSpecH (for the project preview window). The PF_World* contains the width and height to use, but make sure you take the required_region0 into account, if its non-NULL. AEIO_DrawSparseFrame( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, AEIO_Quality qual, const AEIO_RationalScale *rs0, const A_Time *tr, const A_Time *duration0, const A_Rect *required_region0, PF_World *wP, A_long*originx, A_long*originy, AEIO_DrawingFlags*draw_flagsP);
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide the dimensions (and, if necessary, scaling factor) of the video in the AEIO_InSpecH. AEIO_GetDimensions( AEIO_BasicData*basic_dataP, AEIO_InSpecH pinH, const AEIO_RationalScale *rs0, A_long *width0, A_long *height0);
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide the duration of an AEIO_InSpecH. AEIO_GetDuration( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, A_Time *tr);
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide the timebase of an AEIO_InSpecH. AEIO_GetTime( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, A_Time *tr);
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide sound from an AEIO_InSpecH, in the format indicated in the AEIO_GetSoundPB*. AEIO_GetSound( AEIO_BasicData *basic_dataP, AEIO_InSpecHpinH, const AEIO_GetSoundPB*gs_pbP, AEIO_SndWorldH worldH);
AEIO_Err_USE_DFLT_CALLBACK allowed. Provide the time of the next frame (in the source footages timebase) within the AEIO_InSpecH. AEIO_InqNextFrameTime( AEIO_BasicData *basic_dataP, AEIO_InSpecH pinH, const A_Time *base_time_tr, AEIO_TimeDir time_dir, A_Boolean *found0, A_Time*key_time_tr0);
Undoable. Add a keyframe to a stream. This does not change the value of the parameter; it just inserts a keyframe into the stream. The stream is unchanged if a keyframe already exists at that time. AEGP_InsertKeyframe( AEGP_StreamRefHstreamH, AEGP_LTimeMode time_mode, const A_Time *timePT, AEGP_KeyframeIndex *key_indexP);
Undoable. Deletes a keyframe from a stream. All indexes greater than key_index will be invalidated. AEGP_DeleteKeyframe( AEGP_StreamRefHstreamH, AEGP_KeyframeIndex key_index);
Retrieves the time of the indexed keyframe. AEGP_GetKeyframeTime( AEGP_StreamRefHstreamH, AEGP_KeyframeIndex key_index, AEGP_LTimeMode time_mode, A_Time *timePT);
Table 72: Keyframe Suite Function
Obtain the value(s) within a keyframe. Dispose of the AEGP_StreamValue when done using AEGP_DisposeStreamValue(). AEGP_GetNewKeyframeValue( AEGP_PluginID aegp_plugin_id, AEGP_StreamRefH streamH, AEGP_KeyframeIndex key_index, AEGP_StreamValue *valueP);
Undoable. Set the value of an indexed keyframe. valueP is not adopted by After Effects. AEGP_SetKeyframeValue( AEGP_StreamRefH AEGP_KeyframeIndex const AEGP_StreamValue streamH, key_index, *valueP);
Provides the number of data value dimensions. User interaction (making a layer 3d) can change this, so its rarely a good idea to cache the returned value. AEGP_GetStreamValueDimensionality( AEGP_StreamRefH streamH, short *value_dimPS);
Provides the number of temporal dimensions for the AEGP_StreamRefH,needed for use with AEGP_SetKeyframeTemporalEase. AEGP_GetStreamTemporalDimensionality( AEGP_StreamRefH streamH, short *temporal_dimPS);
Obtains the values of a keyframes spatial tangents. Disposed of the values using AEGP_DisposeStreamValue(). AEGP_GetNewKeyframeSpatialTangents( AEGP_PluginID aegp_plugin_id, AEGP_StreamRefH streamH, AEGP_KeyframeIndex key_index, AEGP_StreamValue *in_tanP0, AEGP_StreamValue *out_tanP0);
Undoable. Set the values of an indexed keyframes spatial tangents. Pass NULL for a value you want unchanged. in_tanP0 and out_tanP0 are not adopted by After Effects. AEGP_SetKeyframeSpatialTangents( AEGP_StreamRefH streamH, AEGP_KeyframeIndex key_index, const AEGP_StreamValue *in_tanP0, const AEGP_StreamValue *out_tanP0);
Retrieve the temporal ease values for an indexed keyframe. AEGP_GetKeyframeTemporalEase( AEGP_StreamRefH streamH, AEGP_KeyframeIndex key_index, A_long dimensionL, AEGP_KeyframeEase *in_easeP0, AEGP_KeyframeEase *out_easeP0);
Adobe After Effects CS5.5 Whats New
Adobe After Effects CS5.5
Transform moving images
Deliver cinematic visual effects and sophisticated motion graphics with Adobe After Effects CS5.5 software, the industry-leading native 64-bit animation and compositing application, now with sophisticated stabilization, lens and lighting effects, and the most efficient performance ever.
After Effects CS5.5 delivers 64-bit performance that dramatically improves the experience of creating high resolution content. Streamlined tools and tight integration with other Creative Suite components accelerate your workflow, and an open-ended environment fosters creative experimentation. Realize your vision quickly and efficiently with a comprehensive set of tools designed to help you solve any creative challenge. Deliver your completed projects to a wide range of formats, from large-format feature films and high definition television to websites and mobile devices. After Effects CS5.5 adds the Warp Stabilizer, which raises the quality of handheld footage, and Camera Lens Blur, which faithfully recreates the look of a defocused camera lens, whether applied as an effect or with the After Effects 3D camera. These new features add to a wide range of innovative 2D and 3D creation, compositing, and animation tools in After Effects. New timecode support takes the guesswork out of selecting source footage directly, and a stereoscopic 3D workflow speeds what is otherwise a tedious setup process. Take advantage of enhanced RED camera support added in the 10.0.1 upgrade of After Effects CS5 by working with Red Rocket cards and accessing RMD metadata. Import Cinema DNG files, and export comps as XDCAM EX files. Expanded color look-up-table (LUT) support helps you ensure accuracy across a variety of imagecreation and delivery platforms.
Adobe After Effects CS5.5 is also available as a component of Adobe Creative Suite 5.5 Production Premium and Adobe Creative Suite 5.5 Master Collection software. Adobe Creative Suite 5.5 Production Premium combines full versions of: dobe Premiere Pro CS5.5 A dobe After Effects CS5.5 A dobe Photoshop CS5 Extended A dobe Audition CS5.5 A Adobe Flash Catalyst CS5.5 dobe Flash Professional CS5.5 A dobe Illustrator CS5 A Adobe OnLocation CS5 dobe Encore CS5 A Additional components: Adobe Device Central CS5.5 Adobe Bridge CS5 Adobe Media Encoder CS5.5 Special suite feature: dobe Dynamic Link A Integrates with Adobe CS Live online services*
Subscription option Get the same product with low monthly payments. Visit www.adobe.com/cssubscription to learn more.
Warp Stabilizer automatically smooths the motion of a handheld shot without creating keyframes. It offers easy-to-use controls to define the amount of stabiilization (and thus the amount of cropping) applied.
Top new features Smooth a camera move with Warp Stabilizer (Page 2) reate beautiful soft-focus effects C with Camera Lens Blur (Page 3) Take the guesswork out of edits with source timecode support (Page 4) Effortlessly establish a stereoscopic 3D workflow (Page 5) ontrol light intensity falloff C (Page 6) Work with more high-definition source formats (Page 6) Make use of additional LUTs (Page 7) Export XDCAM EX footage (Page 7) Collaborate easily with colleagues still using After Effects CS5 (Page 7) Benefit from small changes that make a big difference (Page 7)
Who uses After Effects?
Motion graphics designers and visual effects artists use After Effects to produce intricately designed short-form content such as TV commercials, broadcast graphics, and film titles, and to create a wide range of visual effects shots. After Effects is able to handle virtually any animation and compositing task, and offers timesaving integration with other essential toolsAdobe Photoshop and Illustrator software, the video editing software Adobe Premiere Pro, and 3D modeling applications such as Maxon CINEMA 4D and Autodesk Maya. A rich ecosystem of third-party plug-ins means highly specialized solutions are readily available. Video editors and other post-production professionals use After Effects to complement nonlinear editing tools such as Adobe Premiere Pro because it offers an efficient, well-integrated solution for delivering higher production values. When designing attention-getting show openers, lower thirds, and other types of motion graphics, After Effects offers timesaving presets and templates as well as the ability to refine virtually every aspect of every design element. Video editors also use After Effects for a wide variety of post-production tasks, including color correction, motion tracking and stabilization, and keying and rotoscoping. Interactive designers turn to After Effects because it offers flexible tools they can use to prepare dynamic media that integrates well with interactive projects and the tools used to create them. Whether theyre creating videos with transparent backgrounds that can be composited with other elements in real time in Flash Player, designing snippets of persistent motion that add richness to an interactive experience, or creating visually distinctive text animations, interactive designers benefit from tight integration between After Effects and Adobe Flash Professional software.
Top new features of Adobe After Effects CS5.5
Smooth a camera move with Warp Stabilizer
Handheld footage is often shaky, with distracting motion artifacts, and its simply not practical to use a counter-balanced camera rig or keep a dolly or crane ready for every moving shot. Warp Stabilizer provides an innovative solution that makes hand-held footage look as if it had been shot with a complicated, expensive camera rig. It can even use pixel analysis to resolve artifacts related to motion and parallax. You cant stabilize a shot without scaling somewhat to compensate for missing areas of frame, but this new approach requires less zooming than most available alternatives. You can use Warp Stabilizer either to smooth the existing motion of a camera while preserving the movement, or to create a locked-off shot, with no camera movement whatsoever.
Warp Stabilizer offers you a good deal of control over the automated result without the need for any actual keyframes in the timeline. The Subspace Warp option, chosen by default, performs pixel analysis to correct for motion artifacts. This correction is necessary to complement the change in perspective that results from stabilization, which changes parallax within the shot.
You can see a preliminary result in just one step: Apply Warp Stabilizer to the source layer, and let After Effects perform analysis and stabilization. Analysis begins automatically without the need to set tracking points or make any decisions whatsoever. Stabilization progress is displayed onscreen in a two-step process, first analyzing and then stabilizing; once the second step is complete, the result is ready for immediate review. But Warp Stabilizer doesnt just smooth the motion of the camera. It also will remove motion artifacts that otherwise remain after stabilization. Warp Stabilizer processes individual areas of the frame separately to compensate for parallax. If these corrections are not desired, other modes can be used to stabilize only perspective, or scale and rotation, or even just position.
What is parallax?
Parallax is the phenomenon which causes objects closer to a camera to move more, relative to the frame, than do items further away. It can also lead objects in frame to move in opposite directions; for example, if the camera revolves around a mid-ground subject, the foreground and background will move in opposite directions.
The Warp Stabilizer effect offers further refinements as well. You can raise or lower the default amount of smoothness, which has a direct effect on the amount of automatic scaling. In the advanced controls, you can control whether to create a smoother shot with more cropping, or reduce the amount of both cropping and scaling by reducing the overall degree of smoothing. You also have control over image behavior at the borders. In some cases, reducing the amount of cropping and scaling will reveal blank space at the edges of the frame where there is no image data. When you choose the method called Stabilize And Synthesize Edges, the borders automatically are filled in using information from Warp Stabilizer displays progress (during analysis) and then control adjacent frames. In other cases you over the result. may prefer to crop without scaling or just to stabilize, leaving the gaps at the edge of frame in place.
Create soft-focus effects with Camera Lens Blur
Camera lens blur re-creates in post-production the (often beautiful, even fascinating) abstract characteristics that appear in the defocused areas of a camera image. With this effect, footage shot in perfect focus can take on the elegant attributes of a soft focus image. This realistic blur can be applied with the new Camera Lens Blur effect or generated automatically via Depth Of Field controls in the After Effects camera. In soft focus areas, Camera Lens Blur creates edge halos in the shape of the iris blades, just as a real, defocused camera lens does. The iris shape (from triangle up to decagon, representing the number of blades in the camera iris) determines the shape of a halo. Alongside this control are a number of other options to specify the exact characteristics of the iris.
Enabling depth-of-field blur with the After Effects camera activates camera blur controls, including Iris Shape. The amount of blur is determined by the focus distance and aperture settings.
What is bokeh? Bokeh is a term originally coined in Japan for the qualities of defocused light areas as seen through a lens. Points of light become circles of confusionbright disks that take on the shape of the camera irisas seen in many cinematic night shots. Although occasionally regarded as a flaw, bokeh more often is viewed as a lovely and dvesirable way to introduce visual interest using shallow depth of field.
You can also create bokeh effects when overbright highlights are present in 32 bpc mode. These occur in After Effects when you raise the intensity of 3D lights, or even more simply when you change the highlight gain, threshold, and saturation controls. These are useful to create realistic highlights, should you be working with source material without true over-range values. If you use the After Effects camera depth-of-field settings with 3D layers, then the Depth of Field, Focus Distance, and Aperture settings work together just as in previous versions to allow full control over rack focus effects in actual 3D space. New options in the Camera section of the Layer menu allow you to link the Point Of Interest and Zoom Distance, to focus on a selected layer, or even to follow focus on an animated layer. The result of these changes is that the behaviorand therefore, the lookof shallow depth of field from the After Effects camera now more closely resembles those produced by a real camera. With the Camera Lens Blur effect, a separate layer can serve as a map to create depth-of-field effects in a 2D scene. The effect can also be used without a map to defocus the entire scene equally. You can create rack focus effects by adjusting the focal distance setting, converting
whichever channel values you specify to grayscale values that correspond to depth. The white areas of the map are fully blurred, the black areas not at all, while any gray areas transition between the two extremes.
Bokeh blur is the natural result when highlights appear in the defocused area of an image, but it is not a part of most blur operations. The depth-of-field effects on the right bring focus to the face by making the foreground appear defocused.
Take the guesswork out of edits with source timecode support
Timecode support saves steps when working directly with source footage. Without it, you are left to guess based on visual clues or frame counts how a video selection is edited, increasing the likelihood of extra steps and careless errors. Suppose that an editor wants you to check specific frames to evaluate how well the background can be color keyed. With timecode information, you can be confident youre reviewing the same images. Whereas previously you needed a nonlinear editor such as Adobe Premiere Pro to access timecode, you now can save time and avoid ambiguity by accessing this data directly in After Effects. Timecode is embedded in source media when recorded and used to log takes when edited. Timecode hours, minutes, seconds, and frames settings are absolute and do not change, making it possible to determine exactly where a clip begins and ends. Most video formats, including QuickTime, AVI, Broadcast WAV, DPX, and some variations of MXF embed timecode data that can be read by After Effects. Timecode offsets can be recorded as XMP metadata. Timecode data are automatically imported with eligible source files and appear in the Project panel. You can search for a clip using the source data. A set of clips can be sorted in chronological order, regardless of clip names or other attributes, just by clicking on the In Point column heading. When working with a large project, you can organize source clips by the reel on which they were shot; this information also appears directly in the Project panel.
After Effects can read embedded source timecode data, enabling more precision when working directly with source footage. If a tape name has been specified, it appears in the Project panel along with the in and out points of a source clip.
The Timecode effect, which displays timecode graphically when applied to a clip, has also been updated to either read source timecode directly or to use values based on composition timing or whatever values you choose. This allows you not only to display accurate timecode in a composition containing a source clip, but also to use timecode as a customizable graphical element in compositions. While you may still want to do the majority of your previewing and editing in applications designed for that purpose, having this capacity in After Effects gives you a sure-fire method to get the numbers right.
Easily establish a stereoscopic 3D workflow
Expand your creative toolset Open up creative possibilities as you tackle a broad spectrum of planning, production, and post-production tasks with Adobe Creative Suite 5.5 Production Premium. Get more creative power at an appealing price. In addition to Adobe Premiere Pro, Encore, and OnLocation, CS5.5 Production Premium offers the latest versions of Adobe After Effects, Photoshop Extended, Flash Professional, Flash Catalyst, Audition, and Illustrator. Move up to Production Premium to: Create rich visual effects and sophisticated motion graphics. After Effects gives you everything you need to create opening titles, animated graphics, and visual effects, as well as to create and move images and video in 3D. Eliminate unwanted camera movement and compensate for optic irregularities caused by camera motion with Warp Stabilizer. Enhance 3D for video. Create and enhance 3D and motion-based content and prepare still images and text for all your projects. Work fast with cross-platform 64-bit support, and create stunning HDR images for video backdrops. Record, edit, mix, master, and sweeten audio. With Audition CS5.5now available for Mac and Windowsenjoy a smooth workflow with a fast new audio playback engine, royalty-free content* (available through the Resource Central panel), and deep integration with Adobe Premiere Pro CS5.5. Design interactive experiences. Create video portfolios and other engaging interactive media with easy-to-use Flash Catalyst or with the full power of Flash Professional. For more information, see Adobe Creative Suite 5.5 Production Premium Whats New.
Although stereo 3D projects have been created in After Effects for some time, setup was never as quick and easy. A master composition to preview the stereo effect contains a sub-composition for each eye and a rigged source.
After Effects CS5.5 makes it easier than before to set up a stereo-ready 3D image pipeline for review and output of stereo scenes that use the After Effects camera. Initial setup is nearly instantaneous. Start with a composition containing 3D elements, select the main camera (if one is present) and then simply choose Layer > Create Stereo 3D Rig. A right and a left camera are created flanking the master camera, and a set of nested compositions is established with a stereo 3D view containing left and right eye nested compositions, each of which contains the original source composition viewed with the appropriate camera. The stereo 3D composition includes a control layer with two individual effects already applied, using customizable presets: Stereo 3D Controls and 3D Glasses. The Stereo 3D Controls effect allows you to center around any one of the three cameras and adjust the stereo depth by changing the distance between the left and right views (known as the interaxial or interocular distance). The cameras can remain parallel, or they can converge at the point of interest or zoom distance. This convergence point can then be offset with a slider control. The stereo 3D preview itself is created with the 3D Glasses effect. Significantly enhanced in After Effects CS5.5, this effect includes controls to match the physical setup of source stereo footage. You can fine-tune convergence and vertical alignment (if actual physical cameras were misaligned). This effect produces the actual stereo image, allowing you to choose from one of nine 3D output configurations (interlaced, stereo pair, or various types of anaglyph), allowing you to don 3D glasses and preview directly in After Effects. Because stereo 3D animations often use more than one point of view on the same source material, you can create multiple rigs to correspond to multiple cameras in a single composition. For final output, any changes you make in the master composition are passed through to the composition for each eye.
Control light intensity falloff
In the real world, light intensity diminishes naturally the further lit objects are from the light source. After Effects now gives you the controls you need to simulate natural illumination falloff in a 3D sceneor create other light intensity effects, if so desired. Choose the Inverse Square Clamped falloff setting to recreate the real-world decay of light over distance, in which light intensity naturally falls off by the square of the inverse distance. The Smooth falloff setting allows you to define the exact distance over which light levels decay. With either setting, you can determine at what distance (in pixels) light falloff starts and ends.
Inverse-square lighting falls off naturally, displaying The same four basic choices of light type characteristics of real-world light. previously offered in After Effects Parallel, Spot, Point, and Ambientall remain, with each type (except Ambient, which is equal at all positions and thus does not decay) supporting both types of falloff. You can mix light types, intensities, and shadow casting settings the same way you could in previous releases of After Effects.
Work with more high-definition source formats
As new formats for gathering high definition footage arise, After Effects continues to add support for the most versatile and widely used among them, including native R3D support. The RED ROCKET card for Mac OS and Windows delivers real-time 4K RGB playback and transcoding of R3D files from the RED camera, and After Effects can import those files directly, reducing steps between shooting and post-production. RED RMD files are sidecar files alongside the R3D file that contain information about how the shot is graded in software such as REDCINE-X. After Effects imports and applies these RMD settings on import, so that important decisions about how to interpret the color of the shot are not left behind. In addition to the ability to save and load the latest versions of RMDas well as your own custom presets you can now pick a white point and use either a histogram or a five-point curves interface to adjust red, green, blue, RGB, or Luma values for a clip. You can choose which Color Version is used, and FLUTs, Lift, Gamma, and Gain settings are all supported.
Digital footage is often shot at low contrast, resulting in a color range that differs from the intended final look. Not only does After Effects include a full suite of RED tools and settings to adjust raw source on import, it also supports sidecar RMD files that contain these settings from other applications.
CinemaDNG enables film and video professionals working with RAW digital footagesuch as a time-lapse sequence from a DSLR camerato use an open standard. After Effects CS5.5 now imports CinemaDNG files, offering similar controls on import that apply to DNG files, a still format already in wide use. CinemaDNG helps ensure interoperability and the lasting viability of source footage files.
Work with additional LUTs
Color look-up table (LUT) support helps boost confidence that creative and technical decisions translate properly to final output in a wide variety of situations, and help ensure color consistency across multiple devices. After Effects CS5.5 expands LUT support beyond the popular 3DL and CUBE file formats to also allow the loading of 3DL files with floating point values or 3DMES/Mesh keywords, or those saved from the ASSIMILATE SCRATCH system. A LUT makes it possible to save the color correction performed on a file using a wide range of applications and systems, and simulate those settings exactly within After Effects on a specific piece of footage or final composite. A LUT is also used to simulate how images look when projected via specific film stocks or digital projectors. LUTs are an important part of streamlining complex post-production pipelines that span many locations and use a wide variety of software and hardware.
Export XDCAM EX footage
After Effects can now render in the XDCAM EX format using multiple bit-rates, pixel aspects, and frame rates. This allows you to roundtrip footage shot on currently popular Sony cameras such as the PMW-EX3 so that your output is consistent with files being edited directly from source.
Collaborate easily with colleagues still using After Effects CS5
Expected ship date
Second quarter 2011 Choosing when to upgrade to After Effects CS5.5 is simpler with backward compatibility of saved projects. The new option makes it possible to open a project created in version CS5.5 on a system that has not yet been upgraded from CS5. This option allows you to upgrade your studio even if you anticipate working with clients and freelancers have not yet upgraded. Although After Effects CS5 users do not gain access to the many great features added in this latest version, effects available only in After Effects CS5.5 show up as placeholders, the same way that third-party plug-ins are handled when missing. When the project is reopened in After Effects CS5.5, those settings are restored.
For more information
Product details: www.adobe.com/aftereffects
Benefit from small changes that make a big difference
Each new release of After Effects includes many enhancements that aid workflow and add refinements to existing features, and version CS5.5 is no exception.
mocha for After Effects CS5.5 (included: English UI only)
This latest version of the powerful plug-in from Imagineer Systems first introduced in After Effects CS4features a completely revamped and streamlined interface. With mocha for After Effects you can precisely track whole planes of motion and apply the results in an After Effects composition, greatly increasing your motion tracking, corner pinning and rotoscoping options.
Improved disk caching allows for more efficient rendering. Now enabled by default, with a 20 GB limit, many more frames are eligible for disk caching. Items are cached speculatively when the app is idle, so you dont have to wait for them to be added and purged. Caching frames at any time creates a more responsive work environment. Search history saves recent searches while allowing you to save favorite search terms with a shortcut. You can freely delete items from the 10 item list that is saved. Drag-selection of layers in the Composition panel improves the workflow. A marquee selection selects layers in the same way you might select mask vertices, holding Shift to add or subtract from the existing selection. Create Orbit Null parents the camera to a new null layer named to match that camera. Perform OR searches using commas. Add a comma between entries in a list of search terms, and After Effects will return any item that contains at least one of those text strings. Dual time display in the Timeline panel lets you monitor both the current time display, such as timecode, and the alternate display, such as frames, as well as the current frame rate.
Multicore Intel processor with 64-bit support Mac OS X v10.5.8 or v10.6 2GB of RAM 4GB of available hard-disk space plus 2GB of space for optional content; additional free space required during installation (cannot install on a volume that uses a case-sensitive file system or on removable flash storage devices) 1280x800 display with OpenGL 2.0compatible graphics card DVD-ROM drive QuickTime 7.6.2 software required for QuickTime features Broadband Internet connection required for online services and to validate Subscription Edition (if applicable) on an ongoing basis*
Still using After Effects CS4?
If youre still using After Effects CS4, upgrading to After Effects CS5.5 gives you the huge improvements in performance and efficiency first introduced in After Effects CS5. These features substantially boost productivity in many areas. Native 64-bit supportGet the most out of your hardware investment. As a native 64-bit application, After Effects uses all available RAM so that you can work efficiently on complex HD, 2K, and 4K projects. On average, using data from over 130 performance benchmarks, After Effects CS5 is more than twice as fast as After Effects CS4 (according to independent research firm Pfeiffer Consulting). Roto BrushIsolate moving foreground elements from their backgrounds in a fraction of the time required by other methods. Quickly identify foreground and background elements, and then let the Roto Brush automatically create transparency for you. Refine edges easily for extremely precise results. Rotoscoping a five-second clip was found to be 20x faster with Roto Brush than using the After Effects CS4 workflow (Pfeiffer Consulting). Color Finesse 3 LE (English user interface only)Enjoy an enhanced color correction workflow with Color Finesse 3 LE from Synthetic Aperture. Features include a vibrance control similar to that in Adobe Photoshop Lightroom software, hue and saturation curve controls, 3D LUT export, and highlight recovery. Refine Matte effectApply intelligent edge tracking, dechattering, and motion blurring capabilities to any layer with a problematic alpha channel, such as keyed footage. Digieffects FreeForm (English user interface only)Turn flat objects into virtually any 3D shape using this popular 3D mesh warp plug-in by Digieffects, now included with After Effects.
Intel Pentium 4 or AMD Athlon 64 processor (Intel Core i3, i5, or i7 or or AMD Phenom II recommended); 64-bit support required 64-bit operating system required: Microsoft Windows Vista Home Premium, Business, Ultimate, or Enterprise with Service Pack 1 or Windows 7 2GB of RAM 3GB of available hard-disk space plus 2GB of space for optional content; additional free space required during installation (cannot install on removable flash storage devices) 1280x800 display with OpenGL 2.0compatible graphics card DVD-ROM drive QuickTime 7.6.2 software required for QuickTime features Broadband Internet connection required for online services and to validate Subscription Edition (if applicable) on an ongoing basis* For updates to system requirements and more detailed information about video hardware compatibility, visit www.adobe.com/go/aftereffects_ systemreqs.
Still using After Effects CS3?
For those still using After Effects CS3, upgrading to After Effects CS5.5 also gives you the chance to catch up on all the great features added in After Effects CS4. These features greatly enhance your productivity, as well as provide ground-breaking integration with other Adobe software. QuickSearchInstantly locate any element, or all used or missing footage in a comp or project. Composition Navigator and Mini-FlowchartNavigate quickly between nested compositions with a simple keyboard shortcut and interactive user interface element. Separate X, Y & Z valuesSet unique keyframes for properties with three dimensions, simplifying the process of creating natural motion. Photoshop integrationPlace 3D objects on layers in Photoshop (including the new Repouss layers introduced in Photoshop CS5), paint them using its industry-standard tools, import them into After Effects, and animate them alongside your other 3D layers. Flash integrationExport After Effects compositions as layered projects which can be imported into Flash Professional.
About Adobe Systems Incorporated
Adobe is the worlds leading provider of software solutions to create, manage, and deliver highimpact, reliable digital content. For more information, visit www.adobe.com.
Adobe Systems Incorporated 345 Park Avenue San Jose, CA 95110-2704 USA www.adobe.com
Adobe, the Adobe logo, Adobe Premiere, Adobe Audition, After Effects, Creative Suite, Encore, Flash, Illustrator, Lightroom, OnLocation and Photoshop are either registered trademarks or trademarks of Adobe Systems Incorporated in the United States and/or other countries. AMD Athlon and AMD Phenom are trademarks or registered trademarks of Advanced Micro Devices, Inc. Apple, Mac, and Mac OS are trademarks of Apple Computer, Inc., registered in the United States and other countries. Intel, Intel Core, and Pentium are trademarks or registered trademarks of Intel Corporation or its subsidiaries in the United States and other countries. All other trademarks are the property of their respective owners. 2011 Adobe Systems Incorporated. All rights reserved. 1/11
GT-I5800 D-JIX T820 D7056 WS7014S Zoom 2020 Edition NO 0870 Free Download KDL-55HX800 EC470W NR-B30fg1 SVT-3 PRO E5720 P1500 FM200 KX-TDA 15 Fondue SET K8500 Mini 110 SR-L3616BSS BDZ-T75 20LW030B5 DS209 CJ-N853W IX4-200R Continental 14PV203 Printer STA-1800 YDP-131-YDP-213 Cabrio 251 8025 MS SD-NX10H AD-16X Odelia 452 37LE2R Version 2 CLX-3160 Rcs-55 Minimoog MC-9243JLR SMX-C200BN DP-PRO SGH-X100 29PT9521 12 PDX-4 150 1100P MOP MAX S-100 SHD525XF1 Autocad 2008 YZ85-2008 STR-DB1080 Download MC12AHR GT2715 Wt26OW 7700 PRO CDX-434RF STR-DA7100ES Tutorial AP 541N Linux 4 CA-100 TX-P50g20E Cable Torrent Sunbeam 2346 KLV-21SG2 Minitower MW73V MRV-T303 Hunters System Requirements CFD-S01 Crisis TR 200 DM1002X WD7101CKW Mediaplayer 35 CD189 Class H DEM10 DCR-DVD908E ART X-15 Kodak C613 DSC-T3 PNA 350 Aspire 4730 KDL-32EX600 MM-L7 ZDF290X Zyxel V300 8083 PC SET-40353 Powershot S40 CCD-TR717E Mozart Bandu FX22 Z KDC-MP222 CT-F800 P-60facd UF-580 A-RV401
manuel d'instructions, Guide de l'utilisateur | Manual de instrucciones, Instrucciones de uso | Bedienungsanleitung, Bedienungsanleitung | Manual de Instruções, guia do usuário | инструкция | návod na použitie, Užívateľská príručka, návod k použití | bruksanvisningen | instrukcja, podręcznik użytkownika | kullanım kılavuzu, Kullanım | kézikönyv, használati útmutató | manuale di istruzioni, istruzioni d'uso | handleiding, gebruikershandleiding
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101