// The label is allocated and added to the autorelease pool in one line
// myLabel is created with a retain count of 1
UILabel* myLabel = [[[UILabel alloc] initWithFrame: labelFrame] autorelease];
 
// The label is added to the main view
// Internally, the main view will retain myLabel, giving it a retain
// count of 2
[self.view addSubview: myLabel];
 
// ...
 
// Your function exits, and the next time the autorelease pool is drained,
// myLabel will have release called on it, which will decrement the retain count
// As myLabel is still retained by the main view, it will not be deallocated
// until it is also released by the main view

// This function returns a copy of a C-style string
char* String_Copy(const char* pString)
{
	int SizeOfMemoryNeeded = 0;
	char* pMemoryToReturn = NULL;
 
	// Get the length of the string
	SizeOfMemoryNeeded = strlen(pString);
 
	// Add 1 byte on for the null terminator
	// strlen returns the number of characters in the string,
	// but C-style strings need a byte at the end set to 0
	// to mark where the string stops. (This is known as being null-terminated)
	SizeOfMemoryNeeded += 1;
 
	// Allocate our memory
	pMemoryToReturn = (char*)malloc(SizeOfMemoryNeeded);
 
	// Copy our string
	strcpy(pMemoryToReturn, pString);
 
	// Return the newly allocated memory
	return pMemoryToReturn;
}
 
int main()
{
	const char* pMyString = "This is my string";
	char* pCopiedString = NULL;
 
	// Copy MyString
	pCopiedString = String_Copy(pMyString);
 
	// Now we have a pointer, pCopiedString, which
	// points at the memory we grabbed in String_Copy.
 
	// ....
 
	// We pass our copied string into a function
	SomeFunction(pCopiedString);
 
	// ....
 
	// So now we decide we're going to play nice and clean up
	// our memory that we allocated:
	free(pCopiedString);
}

void SomeFunctionDeepInTheProgram(char* pAString)
{
	// Do some stuff
 
	// We don't need the string any more, so lets delete it
	free(pAString);
}

using System;
using System.Collections.Generic;
using System.Text;
 
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Content.Pipeline;
using Microsoft.Xna.Framework.Content.Pipeline.Serialization;
using Microsoft.Xna.Framework.Content.Pipeline.Serialization.Intermediate;
 
namespace SkinnedModelPipeline
{
    /// <summary>
    /// A class for storing our animation definitions
    /// </summary>
    public class AnimationDefinition
    {
        /// <summary>
        /// The original clip name that was exported by the modelling package
        /// Usually this will be Take 001
        /// </summary>
        public string OriginalClipName
        {
            get;
            set;
        }
 
        /// <summary>
        /// The number of frames in the original animation
        /// </summary>
        public int OriginalFrameCount
        {
            get;
            set;
        }
 
        /// <summary>
        /// A class for storing information about individual clips that we want to create
        /// </summary>
        public class ClipPart
        {
            /// <summary>
            /// The name we have given the clip
            /// </summary>
            public string ClipName
            {
                get;
                set;
            }
 
            /// <summary>
            /// The starting frame of the clip
            /// </summary>
            public int StartFrame
            {
                get;
                set;
            }
 
            /// <summary>
            /// The ending frame of the clip
            /// </summary>
            public int EndFrame
            {
                get;
                set;
            }
 
            /// <summary>
            /// A class for defining events in an animation
            /// </summary>
            public class Event
            {
                /// <summary>
                /// The name of the event
                /// </summary>
                public string Name
                {
                    get;
                    set;
                }
 
                /// <summary>
                /// The frame that the event fires on
                /// </summary>
                public int Keyframe
                {
                    get;
                    set;
                }
            };
 
            /// <summary>
            /// Our list of events in this animation clip
            /// Animation clips do not require events, so this is marked as optional
            /// </summary>
            [Microsoft.Xna.Framework.Content.ContentSerializer(Optional = true)]
            public List<Event> Events
            {
                get;
                set;
            }
        };
 
        /// <summary>
        /// The list of clip parts that we are breaking the original clip into
        /// </summary>
        public List<ClipPart> ClipParts
        {
            get;
            set;
        }
    }
}

#region Using Statements
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
#endregion
 
namespace SkinnedModel
{
    /// <summary>
    /// Information about an event in our animation
    /// </summary>
    public class AnimationEvent
    {
        /// <summary>
        /// The name of the event
        /// </summary>
        public String EventName
        {
            get;
            set;
        }
 
        /// <summary>
        /// The time of the event
        /// </summary>
        public TimeSpan EventTime
        {
            get;
            set;
        }
    }
}

	/// <summary>
        /// Callback events for the animation clips
        /// </summary>
        [ContentSerializer]
        public List<AnimationEvent> Events { get; private set; }
 
	/// <summary>
        /// The name of the clip
        /// </summary>
        [ContentSerializer]
        public string Name { get; private set; }

	/// <summary>
        /// Constructs a new animation clip object.
        /// </summary>
        public AnimationClip(TimeSpan duration, List<Keyframe> keyframes, List<AnimationEvent> events, string name)
        {
            Duration = duration;
            Keyframes = keyframes;
            Events = events;
            Name = name;
        }

        /// <summary>
        /// Converts an intermediate format content pipeline AnimationContentDictionary
        /// object to our runtime AnimationClip format.
        /// </summary>
        static Dictionary<string, AnimationClip> ProcessAnimations(
            AnimationContentDictionary animations, IList<BoneContent> bones,
            ContentProcessorContext context, ContentIdentity sourceIdentity)
        {
            // Build up a table mapping bone names to indices.
            Dictionary<string, int> boneMap = new Dictionary<string, int>();
 
            for (int i = 0; i < bones.Count; i++)
            {
                string boneName = bones[i].Name;
 
                if (!string.IsNullOrEmpty(boneName))
                    boneMap.Add(boneName, i);
            }
 
            // Convert each animation in turn.
            Dictionary<string, AnimationClip> animationClips;
            animationClips = new Dictionary<string, AnimationClip>();
 
            // We process the original animation first, so we can use their keyframes
            foreach (KeyValuePair<string, AnimationContent> animation in animations)
            {
                AnimationClip processed = ProcessAnimation(animation.Value, boneMap, animation.Key);
 
                animationClips.Add(animation.Key, processed);
            }
 
            // Check to see if there's an animation clip definition
            // Here, we're checking for a file with the _Anims suffix.
            // So, if your model is named dude.fbx, we'd add dude_Anims.xml in the same folder
            // and the pipeline will see the file and use it to override the animations in the
            // original model file.
            string SourceModelFile = sourceIdentity.SourceFilename;
            string SourcePath = Path.GetDirectoryName(SourceModelFile);
            string AnimFilename = Path.GetFileNameWithoutExtension(SourceModelFile);
            AnimFilename += "_Anims.xml";
            string AnimPath = Path.Combine(SourcePath, AnimFilename);
            if (File.Exists(AnimPath))
            {
                // Add the filename as a dependency, so if it changes, the model is rebuilt
                context.AddDependency(AnimPath);
 
                // Load the animation definition from the XML file
                AnimationDefinition AnimDef = context.BuildAndLoadAsset<XmlImporter, AnimationDefinition>(new ExternalReference<XmlImporter>(AnimPath), null);
 
                // Break up the original animation clips into our new clips
                // First, we check if the clips contains our clip to break up
                if (animationClips.ContainsKey(AnimDef.OriginalClipName))
                {
                    // Grab the main clip that we are using
                    AnimationClip MainClip = animationClips[AnimDef.OriginalClipName];
 
                    // Now remove the original clip from our animations
                    animationClips.Remove(AnimDef.OriginalClipName);
 
                    // Process each of our new animation clip parts
                    foreach (AnimationDefinition.ClipPart Part in AnimDef.ClipParts)
                    {
                        // Calculate the frame times
                        TimeSpan StartTime = GetTimeSpanForFrame(Part.StartFrame, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
                        TimeSpan EndTime = GetTimeSpanForFrame(Part.EndFrame, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
 
                        // Get all the keyframes for the animation clip
                        // that fall within the start and end time
                        List<Keyframe> Keyframes = new List<Keyframe>();
                        foreach (Keyframe AnimFrame in MainClip.Keyframes)
                        {
                            if ((AnimFrame.Time >= StartTime) && (AnimFrame.Time <= EndTime))
                            {
                                Keyframe NewFrame = new Keyframe(AnimFrame.Bone, AnimFrame.Time - StartTime, AnimFrame.Transform);
                                Keyframes.Add(NewFrame);
                            }
                        }
 
                        // Process the events
                        List<AnimationEvent> Events = new List<AnimationEvent>();
                        if (Part.Events != null)
                        {
                            // Process each event
                            foreach (AnimationDefinition.ClipPart.Event Event in Part.Events)
                            {
                                // Get the event time within the animation
                                TimeSpan EventTime = GetTimeSpanForFrame(Event.Keyframe, AnimDef.OriginalFrameCount, MainClip.Duration.Ticks);
 
                                // Offset the event time so it is relative to the start of the animation
                                EventTime -= StartTime;
 
                                // Create the event
                                AnimationEvent NewEvent = new AnimationEvent();
                                NewEvent.EventTime = EventTime;
                                NewEvent.EventName = Event.Name;
                                Events.Add(NewEvent);
                            }
                        }
 
                        // Create the clip
                        AnimationClip NewClip = new AnimationClip(EndTime - StartTime, Keyframes, Events, Part.ClipName);
                        animationClips[Part.ClipName] = NewClip;
                    }
                }
            }
 
            if (animationClips.Count == 0)
            {
                throw new InvalidContentException(
                            "Input file does not contain any animations.");
            }
 
            return animationClips;
        }
 
        /// <summary>
        /// Gets a TimeSpan value for a frame index in an animation
        /// </summary>
        private static TimeSpan GetTimeSpanForFrame(int FrameIndex, int TotalFrameCount, long TotalTicks)
        {
            float MaxFrameIndex = (float)TotalFrameCount - 1;
            float AmountOfAnimation = (float)FrameIndex / MaxFrameIndex;
            float NumTicks = AmountOfAnimation * (float)TotalTicks;
            return new TimeSpan((long)NumTicks);
        }

        /// <summary>
        /// Converts an intermediate format content pipeline AnimationContent
        /// object to our runtime AnimationClip format.
        /// </summary>
        static AnimationClip ProcessAnimation(AnimationContent animation,
                                              Dictionary<string, int> boneMap,
                                              string clipName)
        {
            List<Keyframe> keyframes = new List<Keyframe>();
 
            // For each input animation channel.
            foreach (KeyValuePair<string, AnimationChannel> channel in
                animation.Channels)
            {
                // Look up what bone this channel is controlling.
                int boneIndex;
 
                if (!boneMap.TryGetValue(channel.Key, out boneIndex))
                {
                    throw new InvalidContentException(string.Format(
                        "Found animation for bone '{0}', " +
                        "which is not part of the skeleton.", channel.Key));
                }
 
                // Convert the keyframe data.
                foreach (AnimationKeyframe keyframe in channel.Value)
                {
                    keyframes.Add(new Keyframe(boneIndex, keyframe.Time,
                                               keyframe.Transform));
                }
            }
 
            // Sort the merged keyframes by time.
            keyframes.Sort(CompareKeyframeTimes);
 
            if (keyframes.Count == 0)
                throw new InvalidContentException("Animation has no keyframes.");
 
            if (animation.Duration <= TimeSpan.Zero)
                throw new InvalidContentException("Animation has a zero duration.");
 
            return new AnimationClip(animation.Duration, keyframes, new List<AnimationEvent>(), clipName);
        }

	// The delegate template for the event callbacks
        public delegate void EventCallback(string Event);
 
        // The reigstered events
        Dictionary<string, Dictionary<string, EventCallback>> registeredEvents = new Dictionary<string, Dictionary<string, EventCallback>>();
        public Dictionary<string, Dictionary<string, EventCallback>> RegisteredEvents
        {
            get { return registeredEvents; }
        }

	// Construct the event dictionaries for each clip
        foreach (string clipName in skinningData.AnimationClips.Keys)
        {
            registeredEvents[clipName] = new Dictionary<string, EventCallback>();
        }

        /// <summary>
        /// Helper used by the Update method to refresh the BoneTransforms data.
        /// </summary>
        public void UpdateBoneTransforms(TimeSpan time, bool relativeToCurrentTime)
        {
            if (currentClipValue == null)
                throw new InvalidOperationException(
                            "AnimationPlayer.Update was called before StartClip");
 
            // Store the previous time
            TimeSpan lastTime = time;
 
            // Update the animation position.
            if (relativeToCurrentTime)
            {
                lastTime = currentTimeValue;
                time += currentTimeValue;
 
                // Check for events
                CheckEvents(ref time, ref lastTime);
 
                // If we reached the end, loop back to the start.
                bool hasLooped = false;
                while (time >= currentClipValue.Duration)
                {
                    hasLooped = true;
                    time -= currentClipValue.Duration;
                }
 
                // If we've looped, reprocess the events
                if (hasLooped)
                {
                    CheckEvents(ref time, ref lastTime);
                }
            }
 
            if ((time < TimeSpan.Zero) || (time >= currentClipValue.Duration))
                throw new ArgumentOutOfRangeException("time");
 
            // If the position moved backwards, reset the keyframe index.
            bool HasResetKeyframe = false;
            if (time < currentTimeValue)
            {
                HasResetKeyframe = true;
                currentKeyframe = 0;
                skinningDataValue.BindPose.CopyTo(boneTransforms, 0);
            }
 
            currentTimeValue = time;
 
            // Read keyframe matrices.
            IList<Keyframe> keyframes = currentClipValue.Keyframes;
 
            while (currentKeyframe < keyframes.Count)
            {
                Keyframe keyframe = keyframes[currentKeyframe];
 
                // Stop when we've read up to the current time position.
                if ((keyframe.Time > currentTimeValue) && (!HasResetKeyframe))
                    break;
 
                // Use this keyframe.
                boneTransforms[keyframe.Bone] = keyframe.Transform;
 
                currentKeyframe++;
 
                if(HasResetKeyframe)
                {
                    currentTimeValue = keyframe.Time;
                    HasResetKeyframe = false;
                }
            }
        }

        /// <summary>
        /// Checks to see if any events have passed
        /// </summary>
        private void CheckEvents(ref TimeSpan time, ref TimeSpan lastTime)
        {
            foreach (string eventName in registeredEvents[currentClipValue.Name].Keys)
            {
                // Find the event
                foreach (AnimationEvent animEvent in currentClipValue.Events)
                {
                    if (animEvent.EventName == eventName)
                    {
                        TimeSpan eventTime = animEvent.EventTime;
                        if ((lastTime < eventTime) && (time >= eventTime))
                        {
                            // Call the event
                            registeredEvents[currentClipValue.Name][eventName](eventName);
                        }
                    }
                }
            }
        }

<?xml version="1.0" encoding="utf-8" ?>
<XnaContent>
 
  <Asset Type="SkinnedModelPipeline.AnimationDefinition">
 
    <!-- The original name of the clip we are breaking up -->
    <OriginalClipName>Take 001</OriginalClipName>
 
    <!-- The total number of frames in the original clip -->
    <OriginalFrameCount>100</OriginalFrameCount>
 
    <!-- The new parts we want -->
    <ClipParts>
 
      <!-- Each item is one of our new clips -->
      <Item>
        <ClipName>Idle</ClipName>
        <StartFrame>0</StartFrame>
        <EndFrame>50</EndFrame>
      </Item>
 
      <Item>
        <ClipName>Fire</ClipName>
        <StartFrame>51</StartFrame>
        <EndFrame>99</EndFrame>
 
        <!-- We can register events in this clip, so we can know when certain frames are hit -->
        <Events>
          <Item>
            <Name>FireFrame</Name>
            <Keyframe>70</Keyframe>
          </Item>
        </Events>
 
      </Item>
 
    </ClipParts>
 
  </Asset>
 
</XnaContent>

            // Create an animation player, and start decoding an animation clip.
            animationPlayer = new AnimationPlayer(skinningData);
 
            // Register an event
            animationPlayer.RegisteredEvents["Fire"].Add("FireFrame", new AnimationPlayer.EventCallback(OnFire));
 
            AnimationClip clip = skinningData.AnimationClips["Fire"];
 
            animationPlayer.StartClip(clip);

        private void OnFire(string EventName)
        {
            // Do something here like create a bullet
        }