Mercurial > hg > enc-imaf

Binary file .DS_Store has changed
Binary file IM_AF Encoder/.DS_Store has changed
--- a/IM_AF Encoder/IM_AM Encoder.xcodeproj/project.pbxproj	Wed Jul 04 22:16:23 2012 +0100
+++ b/IM_AF Encoder/IM_AM Encoder.xcodeproj/project.pbxproj	Thu Jul 26 16:52:19 2012 +0100
@@ -25,11 +25,7 @@
 /* End PBXCopyFilesBuildPhase section */

 /* Begin PBXFileReference section */
-		4A2EDBC71594935300A00D85 /* string.g.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = string.g.h; sourceTree = "<group>"; };
-		4A7662A5159A21DB004344F5 /* Drumbox.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = Drumbox.wav; sourceTree = SOURCE_ROOT; };
-		4A7662A6159A21DB004344F5 /* GTR.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = GTR.wav; sourceTree = SOURCE_ROOT; };
-		4A7662A7159A21DB004344F5 /* Kik.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = Kik.wav; sourceTree = SOURCE_ROOT; };
-		4A7662A8159A21DB004344F5 /* vocal.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = vocal.wav; sourceTree = SOURCE_ROOT; };
+		4A68EDC315A779D800B00130 /* string.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = string.h; path = ../string.h; sourceTree = "<group>"; };
 		4A773E36158A37CC00E2DE6C /* IM_AM Encoder */ = {isa = PBXFileReference; explicitFileType = "compiled.mach-o.executable"; includeInIndex = 0; path = "IM_AM Encoder"; sourceTree = BUILT_PRODUCTS_DIR; };
 		4A773E3A158A37CC00E2DE6C /* main.c */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.c; path = main.c; sourceTree = "<group>"; };
 		4A773E3C158A37CC00E2DE6C /* IM_AM_Encoder.1 */ = {isa = PBXFileReference; lastKnownFileType = text.man; path = IM_AM_Encoder.1; sourceTree = "<group>"; };
@@ -38,7 +34,6 @@
 		4AA6EB54158CF0CC000DCEBC /* stdlib.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdlib.h; sourceTree = "<group>"; };
 		4AE74F40158A43760005EBF9 /* stdarg.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stdarg.h; sourceTree = SOURCE_ROOT; };
 		4AE74F41158A43760005EBF9 /* stddef.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = stddef.h; sourceTree = SOURCE_ROOT; };
-		4AEBEFCC1598DB430043303A /* Bass.wav */ = {isa = PBXFileReference; lastKnownFileType = audio.wav; path = Bass.wav; sourceTree = SOURCE_ROOT; };
 /* End PBXFileReference section */

 /* Begin PBXFrameworksBuildPhase section */
@@ -71,16 +66,11 @@
 		4A773E39158A37CC00E2DE6C /* IM_AM Encoder */ = {
 			isa = PBXGroup;
 			children = (
-				4A7662A5159A21DB004344F5 /* Drumbox.wav */,
-				4A7662A6159A21DB004344F5 /* GTR.wav */,
-				4A7662A7159A21DB004344F5 /* Kik.wav */,
-				4A7662A8159A21DB004344F5 /* vocal.wav */,
-				4AEBEFCC1598DB430043303A /* Bass.wav */,
+				4A68EDC315A779D800B00130 /* string.h */,
 				4AE74F40158A43760005EBF9 /* stdarg.h */,
 				4AE74F41158A43760005EBF9 /* stddef.h */,
 				4A773E45158A3F1F00E2DE6C /* stdio.h */,
 				4AA6EB54158CF0CC000DCEBC /* stdlib.h */,
-				4A2EDBC71594935300A00D85 /* string.g.h */,
 				4A773E3A158A37CC00E2DE6C /* main.c */,
 				4A773E3C158A37CC00E2DE6C /* IM_AM_Encoder.1 */,
 				4A773E44158A384000E2DE6C /* IM_AF Encoder.h */,
Binary file IM_AF Encoder/IM_AM Encoder.xcodeproj/project.xcworkspace/xcuserdata/eugin.xcuserdatad/UserInterfaceState.xcuserstate has changed
--- a/IM_AF Encoder/IM_AM Encoder.xcodeproj/xcuserdata/eugin.xcuserdatad/xcdebugger/Breakpoints.xcbkptlist	Wed Jul 04 22:16:23 2012 +0100
+++ b/IM_AF Encoder/IM_AM Encoder.xcodeproj/xcuserdata/eugin.xcuserdatad/xcdebugger/Breakpoints.xcbkptlist	Thu Jul 26 16:52:19 2012 +0100
@@ -2,30 +2,4 @@
 <Bucket
    type = "1"
    version = "1.0">
-   <FileBreakpoints>
-      <FileBreakpoint
-         shouldBeEnabled = "No"
-         ignoreCount = "0"
-         continueAfterRunningActions = "No"
-         isPathRelative = "1"
-         filePath = "IM_AM Encoder/IM_AF Encoder.h"
-         timestampString = "362491526.773334"
-         startingColumnNumber = "9223372036854775807"
-         endingColumnNumber = "9223372036854775807"
-         startingLineNumber = "47"
-         endingLineNumber = "47">
-      </FileBreakpoint>
-      <FileBreakpoint
-         shouldBeEnabled = "No"
-         ignoreCount = "0"
-         continueAfterRunningActions = "No"
-         isPathRelative = "1"
-         filePath = "IM_AM Encoder/IM_AF Encoder.h"
-         timestampString = "363006066.446204"
-         startingColumnNumber = "9223372036854775807"
-         endingColumnNumber = "9223372036854775807"
-         startingLineNumber = "244"
-         endingLineNumber = "244">
-      </FileBreakpoint>
-   </FileBreakpoints>
 </Bucket>
--- a/IM_AF Encoder/IM_AM Encoder/IM_AF Encoder.h	Wed Jul 04 22:16:23 2012 +0100
+++ b/IM_AF Encoder/IM_AM Encoder/IM_AF Encoder.h	Thu Jul 26 16:52:19 2012 +0100
@@ -14,47 +14,62 @@
 /* for FILE typedef, */
 #include <stdio.h>

+#define maxtracks 10
+#define maxpreset 10
+#define maxrules 10
+
 typedef long long u64;
-typedef long long s64;
 typedef unsigned int u32;
 typedef unsigned short u16;
-#define maxtracks 10

-typedef struct namestrack{
+typedef struct nametrack {
     char title[20];
-}namestrack[maxtracks];
+}nametrack[maxtracks];

-typedef struct FileTypeBox // extends Box('ftyp')
+typedef struct FileTypeBox
 {
+    u32 size;
+    u32 type;          // ftyp
     u32 major_brand;   // brand identifier
     u32 minor_version; // informative integer for the mirror version
-    u32 compatible_brands[5]; //list, to the end of the box, of brands
+    u32 compatible_brands[2]; //list, to the end of the box, of brands
 }FileTypeBox;

 typedef struct MoiveBox //extends Box('moov')
 {
-    struct MovieHeaderBox // extends FullBox('mvhs', version, 0)
+    u32 size;
+    u32 type;       // moov
+
+    struct MovieHeaderBox
     {
+        u32 size;
+        u32 type; // mvhd
+        u32 version; // version + flag
         u32 creation_time;
         u32 modification_time;
-        u32 timescale; // specifies the time-scale for the entire presentation (units per second)
+        u32 timescale; // specifies the time-scale
         u32 duration;
         u32 rate;  // typically 1.0
-        u32 volume; // typically full volume
+        u16 volume; // typically full volume
         u16 reserved; // =0
-        u32 reserved2 [2]; //=0
-        u32 matrix [9]; // information matrix for video (u,v,w)
+        u32 reserved2[2]; //=0
+        u32 matrix[9]; // information matrix for video (u,v,w)
         u32 pre_defined[6]; // =0
         u32 next_track_ID; //non zero value for the next track ID
-    }MovieHeaderBox; //max 10 tracks
+    }MovieHeaderBox;

-    struct TrackBox // extends Box('trak')
+   struct TrackBox
     {
-        struct TrackHeaderBox // extends FullBox('tkhd', version, flags)
+        u32 size;
+        u32 type;
+        struct TrackHeaderBox
         {
+            u32 size;
+            u32 type;
+            u32 version; // version + flag
             u32 creation_time;
             u32 modification_time;
-            u32 track_ID; // identifies this track and are never re	-used and cannot be zero
+            u32 track_ID;
             u32 reserved; // =0
             u32 duration;
             u32 reserved2[2]; // =0
@@ -66,231 +81,243 @@
             u32 width; // video
             u32 height; // video
         }TrackHeaderBox;
-        struct TrackReferenceBox // extends Box('tref')
-        {
-            u32 reference_type; //shall be set to one of the following values: hint, cdsc, hind...
-            u32 track_ID; // provides a reference from the container track to another track
-        }TrackReferenceBox;
-        struct EditListBox //extends FullBox('elst',version,0)
-        {
-            u32 segment_duration;
-            u32 media_time;
-            u16 media_rate_integer;
-            u16 media_rate_fraction;
-        }EditListBox;
+
         struct MediaBox // extends Box('mdia')
         {
+            u32 size;
+            u32 type;
             struct MediaHeaderBox // extends FullBox('mdhd', version,0)
             {
+                u32 size;
+                u32 type;
+                u32 version; // version + flag
                 u32 creation_time;
                 u32 modification_time;
                 u32 timescale;
                 u32 duration;
-                u16 language[3]; // [pad,5x3] = 16 bits and pad = 0
+                u16 language; // [pad,5x3] = 16 bits and pad = 0
                 u16 pre_defined; // =0
             }MediaHeaderBox;
-            struct HandlerBox // extends FullBox('hdlr', version =0, 0)
+           struct HandlerBox
             {
+                u32 size;
+                u32 type;
+                u32 version; // version = 0 + flag
                 u32 pre_defined; // =0
                 u32 handler_type; // = 'soun' for audio track, text or hint
                 u32 reserved[3]; // =0
-                char name[20]; // string in UTF-8 characters which gives a human-readable name for track
-            }HandlerBox;
-            struct MediaInformationBox //extends Box('minf')
+               unsigned char data[5]; // Does not work! only 4 bytes
+
+            }HandlerBox;
+             struct MediaInformationBox //extends Box('minf')
             {
+                u32 size;
+                u32 type;
                 // smhd in sound track only!!
-                struct SoundMediaHeaderBox // extends FullBox('smhd', version =0, 0)
+               struct SoundMediaHeaderBox
                 {
+                    u32 size;
+                    u32 type;
+                    u32 version;
                     u16 balance; // =0 place mono tracks in stereo. 0 is center
                     u16 reserved; // =0
                 }SoundMediaHeaderBox;
-                // hmhd in hint track only!!
-                struct HintMediaHeaderBox //extends FullBox('hmhd', version =0, 0)
+
+               struct DataInformationBox //extends Box('dinf')
                 {
-                    u16 maxPDUsize; //size of largest PDU in this (hint) stream
-                    u16 avgPDUsize; // average size of a PDU over the entire presentation
-                    u32 maxbitrate; //max rate in bits/sec over any window of one second
-                    u32 avgbitrate; // rate in bits/sec over entire presentation
-                    u32 reserved; // =0
-                }HintMediaHeaderBox;
-                //struct NullMediaHeaderBox // extends FullBox ('nmhd', version=0, flags)
-                //{}NullMediaHeaderBox;
-                struct DataInformationBox //extends Box('dinf')
-                {
-                    struct DataEntryUrlBox //extends FullBox('url', version=0, flags)
+                    u32 size;
+                    u32 type;
+                    struct DataReferenceBox
                     {
+                        u32 size;
+                        u32 type;
                         u32 flags;
-                        char *location; // UTF8 char
-                    }DataEntryUrlBox;
-                    struct DataEntryUrnBox // extends FullBox('urn', version=0,flag)
-                    {
-                        char *name;
-                        char *location;
-                    }DataEntryUrnBox;
-                    //struct DataReferenceBox // extends FullBox('dref',version=0,flag)
-                    //{
-                    //    u32 entry_count; // counts the actual entries. See bucle in page 44.
-                    //}DataReferenceBox;
+                        u32 entry_count; // counts the actual entries.
+                        struct DataEntryUrlBox //extends FullBox('url', version=0, flags)
+                        {
+                            u32 size;
+                            u32 type;
+                            u32 flags;
+                        }DataEntryUrlBox;
+                    }DataReferenceBox;
                 }DataInformationBox;
                 struct SampleTableBox // extends Box('stbl')
                 {
-                    struct SampleEntry
+                    u32 size;
+                    u32 type;
+                    struct TimeToSampleBox{
+                        u32 size;
+                        u32 type;
+                        u32 version;
+                        u32 entry_count;
+                        u32 sample_count[3000];
+                        u32 sample_delta[3000];
+                    }TimeToSampleBox;
+                    struct SampleDescriptionBox // stsd
                     {
-                        u32 format;
-                        char reserved[6]; //=0
-                        u16 data_reference_index; // index of data reference to use to retrieve data
-                                                  // associated with samples that use this sample descrip.
-                                                  // Data ref are stored in Data Ref Box
-                    }SampleEntry;
-                    struct HintSampleEntry // extends SampleEntry(protocol)
-                    {
-                        char data;
-                    }HintSampleEntry;
-                    struct BitRateBox // extends Box('btrt')
-                    {
-                        u32 bufferSizeDB; // size of the decoding buffer
-                        u32 maxBitrate;
-                        u32 avgBitrate;
-                    }BitRateBox;
-                    struct MetaDataSampleEntry{}MetaDataSampleEntry;
-                    struct XMLMetaDataSampleEntry // extends MetaDataSampleEntry ('metx')
-                    {
-                        char *namespace; // string  of the schema for the timed XML metadata. Identify
-                                        // the type of metadata.
-                    }XMLMetaDataSampleEntry;
-                    struct TextMetaDataSampleEntry // extends MetaDataSampleEntry('mett')
-                    {
-                        char *mime_format;
-                    }TextMetaDataSampleEntry;
-                    struct URIBox // extends FullBox('uri',version=0,0)
-                    {
-                        char *theURI;
-                    }URIBox;
-                    struct URIInitBox
-                    {
-                        char *uri_initialization_data;
-                    }URIInitBox;
-                    struct URIMetaSampleEntry
-                    {
-                        struct URIBox the_label;
-                    }URIMetaSampleEntry;
-                    //Audio Sequences
-                    struct AudioSampleEntry // extends SampleEntry(codingname)
-                    {
-                        u32 reserved[2]; // =0
-                        u16 channelcount; // =2 number of channels 1 mono 2 stereo
-                        u16 samplesize; // =16
-                        u16 pre_defined; // =0
-                        u16 reserved2; //=0
-                        u32 samplerate; // {default samplerate of media}<<16 = 16.16
-                    }AudioSampleEntry;
-                    struct SampleDescriptionBox // unsigned int(32) handler_type
-                    {
-                        u32 handler_type;
-                        u32 entry_count; // number of entries
+                        u32 size;
+                        u32 type;
+                        u32 version;
+                        u32 entry_count; // = 1 number of entries
+                    //    unsigned char esds[88];
+                        struct AudioSampleEntry{
+                            u32 size;
+                            u32 type;   //mp4a
+                            char reserved[6];
+                            u16 data_reference_index; // = 1
+                            u32 reserved2[2];
+                            u16 channelcount; // = 2
+                            u16 samplesize; // = 16
+                            u32 reserved3;
+                            u32 samplerate; // 44100 << 16
+                     //       unsigned char esds[81];
+                            struct ESbox{
+                                u32 size;
+                                u32 type;
+                                u32 version;
+                                struct ES_Descriptor{
+                                    unsigned char tag;
+                                    unsigned char length;
+                                    u16 ES_ID;
+                                    unsigned char mix;
+                                    struct DecoderConfigDescriptor{
+                                        unsigned char tag;
+                                        unsigned char length;
+                                        unsigned char objectProfileInd;
+                                        u32 mix;
+                                        u32 maxBitRate;
+                                        u32 avgBitrate;
+                                     /*   struct DecoderSpecificInfo{
+                                            unsigned char tag;
+                                            unsigned length;
+                                           // unsigned char decSpecificInfosize;
+                                            unsigned char decSpecificInfoData[2];
+                                        }DecoderSpecificInfo;
+                                   */ }DecoderConfigDescriptor;
+                                    struct SLConfigDescriptor{
+                                        unsigned char tag;
+                                        unsigned char length;
+                                        unsigned char predifined;
+                                    }SLConfigDescriptor;
+                                  }ES_Descriptor;
+                            }ESbox;
+                        }AudioSampleEntry;
                     }SampleDescriptionBox;
-                    struct TimeToSampleBox // extends FullBox('stts',version =0,0)
-                    {
+                    struct SampleSizeBox{
+                        u32 size;
+                        u32 type;
+                        u32 version;
+                        u32 sample_size; // =0
+                        u32 sample_count;
+                        u32 entry_size[8000];
+                    }SampleSizeBox;
+                    struct SampleToChunk{
+                        u32 size;
+                        u32 type;
+                        u32 version;
                         u32 entry_count;
-                        int i;
-                        u32 sample_count;
-                        u32 sample_delta;
-                    }TimeToSampleBox;
-                    struct SampleToChunkBox // extends FullBox('stsc',version = 0,0)
-                    {   //chunk -> contiguous set of samples for one track
+                        u32 first_chunk;
+                        u32 samples_per_chunk;
+                        u32 sample_description_index;
+                    }SampleToChunk;
+                    struct ChunkOffsetBox{
+                        u32 size;
+                        u32 type;
+                        u32 version;
                         u32 entry_count;
-                        u32 first_chunk; // index of the first chunk in this run of chunks that share the
-                                         // same samples-per-chunk and sample-descriprion-index.
-                                         // The index of the first chunk in a track = 1.
-                        u32 samples_per_chunk; // number of samples in each o these chunks.
-                        u32 sample_description_index; // index of the sample entry that describes the samples
-                                                      // in this chunk.
-                    }SampleToChunkBox;
-                    struct SampleSizeBox // extends FullBox('stsz',version=0,0)
-                    {
-                        u32 samples_size; //default samples size.
-                        u32 sample_count; // gives the number of samples in the track.
-                        //Table to store the samples size table if samples have different sizes.
-                        u32 entry_size;
-                    }SampleSizeBox;
-                    struct CompactSampleSizeBox // extends FullBox('stz2',version=0,0)
-                    {
-                        u32 field_size; // 24 bits = 0 + 8 bits = field_size
-                                        // int(field_size) 4,8 or 16 if 4 is used then 1 byte two values
-                        u32 sample_count;
-                        int entry_size;
-                    }CompactSampleSizeBox;
-                    struct ChunkOffsetBox // extends FullBox('stco',version=0,0)
-                    {
-                        u32 entry_count;
-                        u32 chunk_offset; // gives the offset of the start of a chunk into its containing
-                                          // media file
+                        u32 chunk_offset[maxtracks];
                     }ChunkOffsetBox;
-                    struct ChunkLargeOffsetBox // extends('co64',version=0,0)
-                    {
-                        u32 entry_count;
-                        u64 chunk_offset;
-                    }ChunkLargeOffsetBox;
                 }SampleTableBox;
             }MediaInformationBox;
         }MediaBox;
     }TrackBox[maxtracks]; // max 10 tracks
-    struct GroupContainerBox // extends Box('grco')
+/*   struct GroupContainerBox // extends Box('grco')
     {
-        u16 num_groups; // number the groups contained in the Group Container Box
+        u16 num_groups;
         struct GroupBox //extended FullBox('grup', version=0,flags)
         {
             int flags; //display disable & edit disable. See page 9 ISO23000-12
             u32 group_ID; //uniquely identifies a group
             u16 num_elements; //num elementes involved in the group
             u32 element_ID[10]; //size [num_elements]
-            char group_activation_mode; //flag that defines the way the elementes of the group are activated.
-            u16 group_activation_elements_number; // activate only if group_activation_mode == 2. Default=0
+            char group_activation_mode;
+            u16 group_activation_elements_number;
             u16 group_reference_volume; // reference group volume
             char group_name[30]; // string UTF-8
             char group_description[100]; // string
         }GroupBox[10];
     }GroupContainerBox;
+*/
     struct PresetContainerBox // extends Box('prco')
     {
-        char num_preset;
-        char default_preset_ID; // indicates preset ID activated at initial conditionwithout
-                                //user interaction. Its default value takes the smallest preset_ID.
+        u32 size;
+        u32 type;
+        unsigned char num_preset;
+        unsigned char default_preset_ID;
         struct PresetBox //extends FullBox('prst',version=0,flags)
         {
-            int flags;
-            char preset_ID;
-            char num_preset_elements;
-            u32 preset_element_ID[10]; //size [num_preset_elements]
-            char preset_type;
-            u16 preset_global_volume;
+            u32 size;
+            u32 type;
+            u32 flags;
+            unsigned char preset_ID;
+            unsigned char num_preset_elements;
+            struct presElemId{
+                u32 preset_element_ID;
+            }presElemId[maxtracks];
+            unsigned char preset_type;
+            unsigned char preset_global_volume;
             //IF preset_type == 1
-            u16 preset_volume_element[10]; // insdie IF
-            char num_input_channel[10];// size [num_preset_elements]
-            //IF preset_type == 2
-            u16 num_updates;
-            u16 update_sample_number; // indicates the sample number when the preset_volume is update
-            //IF preset_type == 3
-            char output_channel_type;
-            char preset_name[30];
-        }PresetBox[10];
+            struct presVolumElem{
+                unsigned char preset_volume_element;
+            }presVolumElem[maxtracks];
+  /*          u16 num_updates;
+            struct updateSample{
+                u16 update_sample_number;
+                struct presVolumElem2{
+                    unsigned char preset_volume_element2;
+                }presVolumElem2[maxtracks];
+            }updateSample[5];
+  */          char preset_name[14];
+        }PresetBox[maxpreset];
     }PresetContainerBox;
-    // HERE it would be the RULES!
+
+    struct RulesContainer{
+        u32 size;
+        u32 type;
+        u16 num_selection_rules;
+        u16 num_mixing_rules;
+        struct SelectionRules{
+            u32 size;
+            u32 type;
+            u32 version;
+            u16 selection_rule_ID;
+            unsigned char selection_rule_type;
+            u32 element_ID;
+            char rule_description[14];
+        }SelectionRules;
+        struct MixingRules{
+            u32 size;
+            u32 type;
+            u32 version;
+            u16 mixing_rule_ID;
+            unsigned char mixing_type;
+            u32 element_ID;
+            u32 key_elem_ID;
+            char mix_description[11];
+        }MixingRules;
+    }RulesContainer;
 }MovieBox;

 typedef struct MediaDataBox // extends Box('mdat')
 {
-    u32 data;  // +/- 16Mbytes
-}MediaDataBox[10];
+    u32 size;
+    u32 type;
+    unsigned char data;
+}MediaDataBox;

-typedef struct FreeSpaceBox // extends Box(free_type)
-{ //may be free or skip
-    u32 data;
-}FreeSpaceBox;
-
-typedef struct MetaBox // extends FullBox('meta',version=0,0)
+/*typedef struct MetaBox // extends FullBox('meta',version=0,0)
 {
-    struct HandlerBox theHandler; //The structure of the metabox is declare by the Handler.
+    struct HandlerBox theHandler;
     struct DataEntryUrlBox dinfo;
     struct ItemLocationBox // extends FullBox('iloc',version,0)
     {
@@ -302,7 +329,7 @@
         int base_offset; // size depends int(8*base_offset_size).
                          // base value for offset calculations.
         u16 extent_count; // Count number of extents into which the resources is fragmented.
-        int extent_index; // size index_size*8, only if version == 1 && indez_size > 0
+        int extent_index;
         int extent_offset; // size offset_size*8
         int extent_length; // size length_size*8
     }ItemLocationBox;
@@ -323,7 +350,7 @@
     }PrimaryItemBox;

 }MetaBox;
-
+*/
 #endif
Binary file IM_AF Encoder/IM_AM Encoder/example1.ima has changed
--- a/IM_AF Encoder/IM_AM Encoder/main.c	Wed Jul 04 22:16:23 2012 +0100
+++ b/IM_AF Encoder/IM_AM Encoder/main.c	Thu Jul 26 16:52:19 2012 +0100
@@ -11,25 +11,22 @@
 #include <string.h>
 #include <time.h>
 #include "IM_AF Encoder.h"
-#define maxtracks 10
-

 /*Prototype*/

 void filetypebx(FileTypeBox *ftyp);
-void mdatbox(MediaDataBox *mdat, int, namestrack *namet, FILE *imf);
-void moovheaderbox(MovieBox *moov, int, int);
-void trackstructure(MovieBox *moov, int, int, namestrack namet);
-void samplecontainer(MovieBox *moov, int);
-void groupscontainer(MovieBox *moov);
-void presetcontainer(MovieBox *moov);
-void metadata(MetaBox *meta);
-int getflags();
-u32 getdurationtrack();
-int getentrycount();
-char setnametrack();
-int getnextID();
-int getelemID();
+int mdatbox(MediaDataBox *mdat, int, FILE *imf, FILE *song, int);
+void moovheaderbox(MovieBox *moov, int, int, int, int, int, int);
+int trackstructure(MovieBox *moov, int, int, int, int, char name[20]);
+int samplecontainer(MovieBox *moov, int, int, char name[20]);
+int sampledescription(MovieBox *moov, int);
+int presetcontainer(MovieBox *moov, int,nametrack namet);
+int rulescontainer(MovieBox *moov);
+void writemoovbox(MovieBox moov, int numtrack,int totaltracks, FILE *imf);
+//void groupscontainer(MovieBox *moov);
+//void metadata(MetaBox *meta);
+int readTrack(MovieBox *moov, int, char name[20]);
+int byterevers(int);


 int main ()
@@ -38,12 +35,12 @@
     FileTypeBox ftyp;
     MediaDataBox mdat;
     MovieBox moov;
-    MetaBox meta;
-    namestrack namet;
+//    MetaBox meta;
+    nametrack namet;
+
     FILE *imf;
-    int numtrack,totaltracks=0, flags;
-//    char typetrack[6];
-
+    int numtrack,totaltracks, sizemdat, durationTrack;
+
     /* Obtain current time as seconds elapsed since the Epoch. */
     time_t clock = time(NULL);

@@ -52,7 +49,6 @@
     printf("How many tracks there will be in your IMAF file?\n");
     scanf("%d",&totaltracks);
     fflush(stdin);
-    //totaltracks = 1;
     while (totaltracks > maxtracks) {
         printf("Sorry, for this version the number maximum ot tracks is 10\n");
         printf("How many tracks there will be in your IMAF file:\n");
@@ -71,122 +67,961 @@
     filetypebx(&ftyp);
     fwrite(&ftyp, sizeof(FileTypeBox),1, imf);

-    //Movie Header - Overall declarations
-    moovheaderbox(&moov, clock, numtrack);
-
-    //For each track write track information
-
-    for (numtrack = 0; numtrack < totaltracks; numtrack++) {
-            //flags = getflags();
-            flags = 1;
-            if (flags == 1){   // Track enable
-
-                trackstructure(&moov, numtrack, clock, namet);
-            }
-    }
-
-    //Groups
-    groupscontainer(&moov);
-
-    //Presets
-    presetcontainer(&moov);
-
-    //Write the information in FILE and close it
-    fwrite(&moov, sizeof(MovieBox),1, imf);
-
-    //Metadata
-    metadata(&meta);
-    fwrite(&meta, sizeof(MetaBox),1, imf);
-
     //Media Data Box - Contains the audio
-    mdatbox(&mdat, totaltracks, &namet, imf);
-
-    //Close File
-    fclose(imf);
+    FILE *song;
+    char nametrack[20], pathdir[60] ="/Users/eugin/Desktop/IM_AF Encoder/Electro/";
+    int numtr, ex = 0;
+    for (numtr=0; numtr<totaltracks; numtr++) {

-    //Testing the code.......
-    imf = fopen ("/Users/eugin/Desktop/IM_AF Encoder/IM_AM Encoder/example1.ima","rb");
-    fread(&ftyp,sizeof(FileTypeBox),1,imf);
-    fclose(imf);
-    printf("minor version %d\n",ftyp.compatible_brands[0]);
-    return 0;
-}
-
-void filetypebx(FileTypeBox *ftyp){
-
-    ftyp->major_brand = 'im01';
-    ftyp->minor_version = '0';
-    ftyp->compatible_brands[0] = 'im01';
-    ftyp->compatible_brands[1] = 'isom';
-    ftyp->compatible_brands[2] = 'im03';
-    ftyp->compatible_brands[3] = 'im12';
-    ftyp->compatible_brands[4] = 'im21';
-}
-
-void mdatbox(MediaDataBox *mdat, int totaltracks, namestrack *namet, FILE *imf){
-
-    int exist, i, cnt, sz;
-    FILE *song;
-    char nametrack[20], pathdir[60] ="/Users/eugin/Desktop/IM_AF Encoder/";
-
-    for (i=0; i<totaltracks; i++) {
-        strcpy(pathdir, "/Users/eugin/Desktop/IM_AF Encoder/");
-        printf("Name of the track number: %d\n", i+1);
+        printf("Name of the track number: %d\n", numtr+1);
         fflush(stdin);
         scanf("%s", nametrack);
+        strcpy(pathdir, "/Users/eugin/Desktop/IM_AF Encoder/Electro/");
         strcat(pathdir, nametrack);
-        exist = 0;
+        ex = 0;
         //Check if the track exist and then open it.
-        while (exist == 0){
+        while (ex == 0){
             song = fopen(pathdir, "rb");
             if((song)==NULL) {
                 printf("Name does not exist. Try again:\n");
                 fflush(stdin);
                 scanf("%s", nametrack);
-                strcpy(pathdir, "/Users/eugin/Desktop/IM_AF Encoder/");
+                strcpy(pathdir, "/Users/eugin/Desktop/IM_AF Encoder/Electro/");
                 strcat(pathdir, nametrack);
-                printf("%s\n",pathdir);
             }else{
-                exist = 1;
+                ex = 1;
             }
         }
-        strcpy (namet[i]->title, nametrack);
-        fseek(song, 0L, SEEK_END);
-        sz = ftell(song);
-        printf("%d \n",sz);
-        //Read track
-        fseek (song, 0, SEEK_SET);
-
-        for (cnt = 0; cnt < 200000; cnt++) {
-        //    printf("%d\n", cnt);
-            fread(&mdat[i]->data, sizeof(u32),1,song);
-            fwrite(&mdat, sizeof(MediaDataBox),1, imf);
-        }
+        strcpy(namet[numtr].title, nametrack);
+        sizemdat = mdatbox(&mdat, totaltracks, imf, song, numtr);
         fclose(song);
     }
+
+    //For each track write track information
+    u32 sizeTRAK = 0;
+    char name[20];
+    durationTrack = (sizemdat*8)/128;
+    printf("Duration: %d\n",durationTrack);
+
+    for (numtrack = 0; numtrack < totaltracks; numtrack++) {
+        strcpy(name,namet[numtrack].title);
+        sizeTRAK =  trackstructure(&moov, numtrack, clock, durationTrack,sizemdat, name)+ sizeTRAK;
+    }
+
+    //Groups
+ //   groupscontainer(&moov);
+
+    //Presets
+    u32 sizePRCO;
+    sizePRCO = presetcontainer(&moov, totaltracks, namet);
+
+    //Rules
+    u32 sizeRUCO;
+    sizeRUCO = rulescontainer(&moov);
+
+    //Movie Header - Overall declarations
+    moovheaderbox(&moov, clock, sizeTRAK, sizePRCO, totaltracks, durationTrack, sizeRUCO);
+
+    writemoovbox(moov,numtrack, totaltracks, imf);
+
+    //Metadata
+    //metadata(&meta);
+    //fwrite(&meta, sizeof(MetaBox),1, imf);
+
+    //Close File
+    fclose(imf);
+
+    return 0;
+}
+
+void filetypebx(FileTypeBox *ftyp){
+    int swap;
+
+    swap = byterevers (24);
+    ftyp->size = swap;
+    swap = byterevers ('ftyp');
+    ftyp->type = swap;
+    swap = byterevers ('im03');
+    ftyp->major_brand = swap;
+    ftyp->minor_version = 0;
+    swap = byterevers ('im03');
+    ftyp->compatible_brands[0] = swap;
+    swap = byterevers ('isom');
+    ftyp->compatible_brands[1] = swap;
+}
+
+int mdatbox(MediaDataBox *mdat, int totaltracks, FILE *imf, FILE *song, int numtr){
+
+    int d, cnt, j, find = 0;
+    int  dat = 0, dat1 = 0, dat2 = 0, dat3 = 0, num_samples = 0;
+    u32 size = 0, swap, sizeMDAT =0;
+
+    fseek(song, 0, SEEK_END);
+    size = ftell(song);
+    fseek(song, 0, SEEK_SET);
+    d=0;
+    cnt = 0;
+    while (d == 0) {
+        find = 0;
+        fread(&dat, sizeof(unsigned char), 1, song);
+        cnt++;
+
+        if (dat == 0xFF) {
+            cnt++;
+            fread(&dat1, sizeof(unsigned char), 1, song);
+            cnt++;
+            fread(&dat2, sizeof(unsigned char), 1, song);
+            cnt++;
+            fread(&dat3, sizeof(unsigned char), 1, song);
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 64 ) {
+                num_samples ++;
+                // printf("Data %d Position: %d\n",dat3, cnt);
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 96 ) {
+                num_samples ++;
+                d=1;
+                find = 1;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 64 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 96 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 100 ) {
+                num_samples ++;
+                d=1;
+                find = 1;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 100 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 64 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 96 ) {
+                num_samples ++;
+                d=1;
+                find = 1;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 64 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 96 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 100 ) {
+                num_samples ++;
+                d=1;
+                find = 1;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 100 ) {
+                num_samples ++;
+                find = 1;
+                d=1;
+            }
+            if (find == 0) {
+                fseek(song, -3, SEEK_CUR);
+                cnt = cnt - 3;
+            }
+        }
+        if (cnt == size) {
+            d = 1;
+        }
+    }
+    size =  size - (cnt - 4);
+    if (numtr == 0) {
+        sizeMDAT = size*totaltracks + 8;
+     //   printf("Size file mdat %d\n",sizeMDAT);
+        swap = byterevers(sizeMDAT);
+        fwrite(&swap, sizeof(u32), 1, imf);
+        swap = byterevers('mdat');
+        mdat->type = swap;
+        fwrite(&mdat->type, sizeof(u32), 1, imf);
+    }
+    fseek(song, cnt - 4, SEEK_SET);
+    for (j=0; j<size; j++) {
+        fread(&mdat->data, sizeof(char), 1, song);
+        fwrite(&mdat->data, sizeof(char), 1, imf);
+    }
+    fclose(song);
+
+    return size;
+}
+
+int samplecontainer(MovieBox *moov, int numtrack, int sizemdat, char name[20]){
+
+    u32 sizeSTSD, sizeSTSZ, swap, num_samples, dat=0;
+
+    //Sample Description Box//
+    sizeSTSD = sampledescription(moov, numtrack);
+
+    //Sample size box//
+    swap = byterevers('stsz');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleSizeBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleSizeBox.version = 0;
+    //Read Track: Fram size and Decoder Times//
+    num_samples = readTrack(moov, numtrack, name);
+    sizeSTSZ = num_samples*4 + 20;
+    swap = byterevers(sizeSTSZ);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleSizeBox.size = swap;
+
+    //Time To Sample Box//
+    u32 sizetime, sizeSTTS;
+    sizetime = byterevers(moov->TrackBox[numtrack].MediaBox.MediaInformationBox.
+                          SampleTableBox.TimeToSampleBox.entry_count);
+    sizeSTTS = 16 + sizetime*4*2;
+    swap = byterevers(sizeSTTS);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.size = swap;
+    swap = byterevers('stts');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.version = 0;
+
+    //Sample To Chunk//
+    u32 sizeSTSC = 28;
+    swap = byterevers(sizeSTSC);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.size = swap;
+    swap = byterevers('stsc');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.version = 0;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.entry_count = swap;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.first_chunk = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.samples_per_chunk = moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleSizeBox.sample_count;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleToChunk.sample_description_index = swap;
+
+    //Chunk Offset Box//
+    u32 sizeSTCO = 20;
+    swap = byterevers(sizeSTCO);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    ChunkOffsetBox.size = swap;
+    swap = byterevers('stco');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    ChunkOffsetBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    ChunkOffsetBox.version = 0;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    ChunkOffsetBox.entry_count = swap;
+    dat = 32 + sizemdat*numtrack;
+    swap = byterevers(dat);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    ChunkOffsetBox.chunk_offset[numtrack] = swap;
+
+    //Sample Table Box //
+    u32 sizeSTBL = 8 + sizeSTSD + sizeSTSZ + sizeSTSC + sizeSTCO + sizeSTTS;
+    swap = byterevers(sizeSTBL);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.size = swap;
+    swap = byterevers('stbl');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.type =swap;
+
+    return  sizeSTBL;
+}
+
+int sampledescription(MovieBox *moov, int numtrack){
+    u32 swap, sizeESD = 35;
+    swap = byterevers(sizeESD);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.size = swap;
+    swap = byterevers('esds');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.version = 0;
+
+    //ES Descriptor//
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.tag = 3;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.length = 21;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.ES_ID = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.mix = 0;
+
+    //Decoder config descriptor//
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.tag = 4;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.length = 13;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.objectProfileInd = 0x6B;
+    swap = byterevers(0x150036B0);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.mix = swap;
+    swap = byterevers(128);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.maxBitRate = swap;
+    swap = byterevers(128);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.avgBitrate = swap;
+
+    //Decoder Specific Info//
+  /*  moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.DecoderSpecificInfo.tag = 5;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.DecoderSpecificInfo.length = 2;
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.DecoderSpecificInfo.decSpecificInfoData[0] = 0xC;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    DecoderConfigDescriptor.DecoderSpecificInfo.decSpecificInfoData[1] = 0x8;
+  */
+    //SLConfig Descriptor//
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    SLConfigDescriptor.tag = 6;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    SLConfigDescriptor.length = 1;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.
+    SLConfigDescriptor.predifined = 2;
+
+    //Audio Sample Entry//
+    u32 sizeMP4a = 36 + sizeESD;
+    swap = byterevers(sizeMP4a);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.size = swap;
+    swap = byterevers('mp4a');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.type =swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[0] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[1] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[2] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[3] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[4] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved[5] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.data_reference_index = 256;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved2[0] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved2[1] = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.channelcount = 512;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.samplesize = 4096; // 16 bits
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.reserved3 = 0;
+    swap = 44100 << 16;
+    swap = byterevers(swap);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.AudioSampleEntry.samplerate = swap;
+
+    //Sample description box //
+    u32 sizeSTSD = 16 + sizeMP4a;
+    swap = byterevers(sizeSTSD);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.size = swap;
+    swap = byterevers('stsd');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.version = 0;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleDescriptionBox.entry_count = swap;
+
+    return sizeSTSD;
+}
+
+int readTrack (MovieBox *moov, int numtrack, char name[20]){
+
+    FILE *song;
+    int d=0, cnt = 0, i=0, j=0, cnt2 = 0, find = 0, swap, num_entr = 0;
+    int  dat = 0, dat1 = 0, dat2 = 0, dat3 = 0, num_samples = 0, end =0, pos = 0;
+    u32 size[8000];
+    char pathdir[60] = "/Users/eugin/Desktop/IM_AF Encoder/Electro/";
+  //  printf("Name: %s\n",name);
+    strcat(pathdir, name);
+
+    song = fopen (pathdir,"rb");
+    if (song == NULL) {
+        printf("Error opening input file\n");
+        system("pause");
+        exit(1);
+    }
+
+    fseek(song, 0, SEEK_END);
+    end = ftell(song);
+    fseek(song, 0, SEEK_SET);
+    d=0, i=0;
+    while (d == 0) {
+        find = 0;
+        fread(&dat, sizeof(unsigned char), 1, song);
+        cnt++;
+
+        if (dat == 0xFF) {
+            cnt++;
+            fread(&dat1, sizeof(unsigned char), 1, song);
+            cnt++;
+            fread(&dat2, sizeof(unsigned char), 1, song);
+            cnt++;
+            fread(&dat3, sizeof(unsigned char), 1, song);
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 64 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+         //       printf("Data %d Position: %d\n",dat3, num_samples,pos);
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 96 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 64 ) {
+               pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+         //       printf("Data %d Position: %d\n",dat3, num_samples,pos);
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 96 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFB && dat2 == 146 && dat3 == 100 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFB && dat2 == 144 && dat3 == 100 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 64 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                //       printf("Data %d Position: %d\n",dat3, num_samples,pos);
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 96 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 64 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                //       printf("Data %d Position: %d\n",dat3, num_samples,pos);
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 96 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 146 && dat3 == 100 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (dat1 == 0xFA && dat2 == 144 && dat3 == 100 ) {
+                pos = cnt - 4;
+                size[num_samples] = pos - cnt2;
+                cnt2 = pos;
+                find = 1;
+                num_samples ++;
+            }
+            if (find == 0) { // Keep reading next data.
+                fseek(song, -3, SEEK_CUR);
+                cnt = cnt - 3;
+            }
+        }
+
+        if (cnt == end) {
+            pos = cnt;
+            size[num_samples] = pos - cnt2;
+            d = 1;
+        }
+    }
+
+    //Save Samples size//
+    swap = byterevers(num_samples);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleSizeBox.sample_count = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    SampleSizeBox.sample_size = 0;
+
+    for (i=0; i< num_samples; i++) {
+        swap = byterevers(size[i+1]);
+        moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+        SampleSizeBox.entry_size[i] = swap;
+    }
+
+  //  printf("Num of samples %d\n",num_samples);
+
+    //Save Decoding Times//
+
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.sample_count[0] = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.sample_delta[0] =0;
+    int t=0,k=1, l =0;
+    num_entr = 1;
+    j = 0;
+    for (i = 1; i< num_samples; i++) {
+        if (j == 8 && l == 0) {
+            swap = byterevers(7);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_count[num_entr] = swap;
+            swap = byterevers(26);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_delta[num_entr] =swap;
+            num_entr ++;
+
+            swap = byterevers(1);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_count[num_entr] = swap;
+            swap = byterevers(27);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_delta[num_entr] =swap;
+            num_entr++;
+            j=0;
+            dat = i;
+            if (k == 6 && t == 0) {
+                l = 1;
+                t = 1;
+                k = 1;
+            }
+            if (k == 6 && t ==1) {
+                l = 1;
+                k = 1;
+            }
+            k++;
+        }
+
+        if (j == 9 && l == 1) {
+
+            swap = byterevers(8);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_count[num_entr] = swap;
+            swap = byterevers(26);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_delta[num_entr] =swap;
+            num_entr ++;
+
+            swap = byterevers(1);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_count[num_entr] = swap;
+            swap = byterevers(27);
+            moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+            TimeToSampleBox.sample_delta[num_entr] =swap;
+            num_entr++;
+            j=0;
+            dat = i;
+            l = 0;
+        }
+        j++;
+    }
+
+    dat = num_samples - dat;
+
+    swap = byterevers(dat);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.sample_count[num_entr] = swap;
+    swap = byterevers(26);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.sample_delta[num_entr] =swap;
+    num_entr++;
+ //   printf("Num entries: %d\n", num_entr);
+    swap = byterevers(num_entr);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+    TimeToSampleBox.entry_count = swap;
+
+    fclose(song);
+    return num_samples;

 }

-void moovheaderbox (MovieBox *moov,int clock, int numtrack){
+int trackstructure (MovieBox *moov, int numtrack, int clock,
+                    int durationTrack, int sizemdat, char name[20]){
+    int swap;
+
+    //Sample Table Box
+    int sizeSTBL = 0;
+    sizeSTBL = samplecontainer(moov, numtrack,sizemdat, name);

-    moov->MovieHeaderBox.creation_time = clock;
-    moov->MovieHeaderBox.modification_time = clock;
-    moov->MovieHeaderBox.timescale = 60;
-//    moov->MovieHeaderBox.duration = getdurationtrack();
-    moov->MovieHeaderBox.duration = 10;
-    moov->MovieHeaderBox.rate = 1;
+    //Data Entry Url Box
+    u32 sizeURL = 12;
+    swap = byterevers(sizeURL);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.DataEntryUrlBox.size = swap;
+    swap = byterevers('url ');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.DataEntryUrlBox.type = swap;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.DataEntryUrlBox.flags = swap; // =1 Track in same file as movie atom.
+
+    //Data Reference
+    u32 sizeDREF = sizeURL+ 16;
+    swap = byterevers(sizeDREF);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.size = swap;
+    swap = byterevers('dref');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.flags = 0;
+    swap = byterevers(1);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.
+    DataReferenceBox.entry_count = swap;
+
+    //Data information Box//
+    u32 sizeDINF = sizeDREF + 8;
+    swap = byterevers(sizeDINF);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.size = swap;
+    swap = byterevers('dinf');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.type = swap;
+
+    //Sound Header Box //
+    u32 sizeSMHD = 16;
+    swap = byterevers(sizeSMHD);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.size = swap;
+    swap = byterevers('smhd');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.version = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.balance = 0;
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.reserved = 0;
+
+    //Media Information Box//
+    u32 sizeMINF = sizeDINF + sizeSMHD + sizeSTBL + 8;
+    swap = byterevers(sizeMINF);
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.size = swap;
+    swap = byterevers('minf');
+    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.type = swap;
+
+    //Handler Box//
+    u32 sizeHDLR = 37;
+    swap = byterevers(sizeHDLR);
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.size = swap;
+    swap = byterevers('hdlr');
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.version = 0;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.pre_defined = 0;
+    swap = byterevers('soun');
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.handler_type = swap;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[0] = 0;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[1] = 0;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[2] = 0;
+    //swap = byterevers('soun');
+    //moov->TrackBox[numtrack].MediaBox.HandlerBox.data = swap;
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.data[0] = 's';
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.data[1] = 'o';
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.data[2] = 'u';
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.data[3] = 'n';
+    moov->TrackBox[numtrack].MediaBox.HandlerBox.data[4] = '\0';
+
+    //Media Header Box//
+    u32 sizeMDHD = 32;
+    swap = byterevers(sizeMDHD);
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.size = swap;
+    swap = byterevers('mdhd');
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.type = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.version = 0;
+    swap = byterevers(clock);
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.creation_time = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.modification_time = swap;
+    swap = byterevers(1000);
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.timescale = swap;
+    swap = byterevers(durationTrack);
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.duration = swap;
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language = 0xC455;
+    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.pre_defined = 0;
+
+    //Media Box//
+    u32 sizeMDIA = sizeMDHD + sizeHDLR + sizeMINF + 8;
+    swap = byterevers(sizeMDIA);
+    moov->TrackBox[numtrack].MediaBox.size = swap;
+    swap = byterevers('mdia');
+    moov->TrackBox[numtrack].MediaBox.type = swap;
+
+    //Track Header//
+    u32 sizeTKHD = 92;
+    swap = byterevers (sizeTKHD);
+    moov->TrackBox[numtrack].TrackHeaderBox.size = swap;
+    swap = byterevers ('tkhd');
+    moov->TrackBox[numtrack].TrackHeaderBox.type = swap ;
+    swap = byterevers (0x00000006);
+    moov->TrackBox[numtrack].TrackHeaderBox.version = swap;
+    swap = byterevers (clock);
+    moov->TrackBox[numtrack].TrackHeaderBox.creation_time = swap;
+    moov->TrackBox[numtrack].TrackHeaderBox.modification_time = swap;
+    swap = byterevers (numtrack+1);
+    moov->TrackBox[numtrack].TrackHeaderBox.track_ID = swap; //From 0x00000001 - 0x7FFFFFFF (dec 2147483647)
+    moov->TrackBox[numtrack].TrackHeaderBox.reserved = 0;
+    swap = byterevers (durationTrack);
+    moov->TrackBox[numtrack].TrackHeaderBox.duration = swap;
+    moov->TrackBox[numtrack].TrackHeaderBox.reserved2[0] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.reserved2[1] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.layer = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.alternate_group = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.volume = 0x1;
+    moov->TrackBox[numtrack].TrackHeaderBox.reserved3 = 0;
+    swap = byterevers (0x00010000);
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[0] = swap;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[1] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[2] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[3] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[4] = swap;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[5] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[6] = 0;
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[7] = 0;
+    swap = byterevers(0x40000000);
+    moov->TrackBox[numtrack].TrackHeaderBox.matrix[8] = swap;
+    moov->TrackBox[numtrack].TrackHeaderBox.width = 0; //just for video
+    moov->TrackBox[numtrack].TrackHeaderBox.height = 0; //just for video
+
+    //Track container
+    u32 sizeTRAK = sizeTKHD + sizeMDIA + 8;
+    swap = byterevers (sizeTRAK); // Size of one track
+    moov->TrackBox[numtrack].size = swap;
+    swap = byterevers ('trak');
+    moov->TrackBox[numtrack].type = swap;
+    return sizeTRAK;
+
+}
+
+int presetcontainer(MovieBox *moov, int totaltracks, nametrack namet){
+
+    int swap, i,j,flag, vol=0;
+//    char num_output_channel = 2; // Stereo
+    unsigned char numpres=0, prestype=0,defaultPreset;
+    char namepres1[14] = "static_track "; // 13
+    u32 sizePRST = 0;
+
+    printf("Presets:\n");
+    printf("Static track volume preset: invariant volume related to each track \n");
+    printf("          --------------------------------------\n");
+    numpres = 1;
+    //Preset Box//
+    for (i=0; i<numpres; i++) {
+        printf("Preset number %d: %s\n",i+1,namepres1);
+        strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, namepres1);
+        sizePRST = 16 + 14 + 4*totaltracks + totaltracks;
+        swap = byterevers(sizePRST);
+        moov->PresetContainerBox.PresetBox[i].size = swap;
+        prestype = 0;
+
+  /*      if (i == 1) {
+            printf("Preset number %d: %s\n",i+1,namepres2);
+            strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, namepres2);
+            sizePRST2 = 16 + 14 + 4*totaltracks + 2 + 2*5*totaltracks;
+            swap = byterevers(sizePRST2);
+            moov->PresetContainerBox.PresetBox[i].size = swap;
+            prestype = 2;
+
+        }
+ */
+        moov->PresetContainerBox.PresetBox[i].num_preset_elements = totaltracks;
+        swap = byterevers('prst');
+        moov->PresetContainerBox.PresetBox[i].type = swap;
+
+        flag = 0x02; // Display Enable Edit Disable
+        swap = byterevers(flag);
+        moov->PresetContainerBox.PresetBox[i].flags = swap;
+
+        moov->PresetContainerBox.PresetBox[i].preset_ID = i+1;
+
+        moov->PresetContainerBox.PresetBox[i].preset_type = prestype;
+        moov->PresetContainerBox.PresetBox[i].preset_global_volume = 100;
+
+        for (j=0; j<totaltracks; j++) {
+            swap = byterevers(j+1);
+            moov->PresetContainerBox.PresetBox[i].presElemId[j].preset_element_ID = swap;
+        }
+
+        for (j=0; j<totaltracks; j++) {
+            printf("Enter volume for %s\n",namet[j].title);
+        //     scanf("%d",&vol);
+        //     printf("Vol: %d\n",vol);
+            vol = 100;
+            moov->PresetContainerBox.PresetBox[i].presVolumElem[j].preset_volume_element = vol; //*0.02
+        }
+
+ /*       if(prestype == 2){ // dynamic track volume preset
+            moov->PresetContainerBox.PresetBox[i].num_updates = 5;
+            ups = 1;
+            for(l=0; l<moov->PresetContainerBox.PresetBox[i].num_updates; l++){
+                moov->PresetContainerBox.PresetBox[i].updateSample[l].update_sample_number = ups;
+                for(j=0; j<totaltracks; j++){
+                    printf("Sample position: %d\n",ups);
+                    printf("Enter volume for %s\n",namet[j].title);
+             //       scanf("%d",&vol);
+                    moov->PresetContainerBox.PresetBox[i].updateSample[l].presVolumElem2[j].
+                    preset_volume_element2 = 0x64;
+                }
+                ups = ups + 200;
+            }
+         }
+  */
+    }
+
+    //Preset Container//
+    u32 sizePRCO = sizePRST + 10;
+    swap = byterevers(sizePRCO);
+    moov->PresetContainerBox.size = swap;
+    swap = byterevers('prco');
+    moov->PresetContainerBox.type = swap;
+    defaultPreset = 1;
+    moov->PresetContainerBox.default_preset_ID = defaultPreset; // Indicates initial preset activated.
+    moov->PresetContainerBox.num_preset = numpres;
+
+    return sizePRCO;
+}
+
+int rulescontainer(MovieBox *moov){
+    int swap;
+    u32 sizeRUSC, elementID, key_elem, sizeRUMX;
+
+    moov->RulesContainer.num_selection_rules = 256; //u16 invert
+    moov->RulesContainer.num_mixing_rules = 256;
+
+    //Selection Rules
+    sizeRUSC = 19 + 14;
+    swap = byterevers(sizeRUSC);
+    moov->RulesContainer.SelectionRules.size = swap;
+    swap = byterevers('rusc');
+    moov->RulesContainer.SelectionRules.type = swap;
+    moov->RulesContainer.SelectionRules.version = 0;
+    moov->RulesContainer.SelectionRules.selection_rule_ID = 256;
+    moov->RulesContainer.SelectionRules.selection_rule_type = 2;
+    elementID = 1;
+    swap = byterevers(elementID);
+    moov->RulesContainer.SelectionRules.element_ID = swap;
+    strcpy(moov->RulesContainer.SelectionRules.rule_description,"Not mute rule");
+
+    //Mixing Rule
+    sizeRUMX = 23 + 11;
+    swap = byterevers(sizeRUMX);
+    moov->RulesContainer.MixingRules.size = swap;
+    swap = byterevers('rumx');
+    moov->RulesContainer.MixingRules.type = swap;
+    moov->RulesContainer.MixingRules.version = 0;
+    moov->RulesContainer.MixingRules.mixing_rule_ID = 512; // Upper rule
+    moov->RulesContainer.MixingRules.mixing_type = 1;
+    elementID = 1;
+    swap = byterevers(elementID);
+    moov->RulesContainer.MixingRules.element_ID = swap;
+    key_elem = 2;
+    swap = byterevers(key_elem);
+    moov->RulesContainer.MixingRules.key_elem_ID = swap;
+    strcpy(moov->RulesContainer.MixingRules.mix_description, "Upper rule");
+
+    //Rule container
+    u32 sizeRUCO = 12 + sizeRUSC + sizeRUMX;
+    swap = byterevers(sizeRUCO);
+    moov->RulesContainer.size = swap;
+    swap = byterevers('ruco');
+    moov->RulesContainer.type = swap;
+
+    return sizeRUCO;
+}
+
+void moovheaderbox (MovieBox *moov,int clock, int sizeTRAK, int sizePRCO, int totaltracks,
+                    int durationTrack, int sizeRUCO){
+    int swap;
+
+    //MovieHeader
+    u32 sizeMVHD = 108;
+    swap = byterevers (sizeMVHD);
+    moov->MovieHeaderBox.size = swap;
+    swap = byterevers ('mvhd');
+    moov->MovieHeaderBox.type = swap;
+    moov->MovieHeaderBox.version = 0;
+    swap = byterevers (clock);
+    moov->MovieHeaderBox.creation_time = swap;
+    moov->MovieHeaderBox.modification_time = swap;
+    swap = byterevers (1000);
+    moov->MovieHeaderBox.timescale = swap;
+    swap = byterevers (durationTrack);
+    moov->MovieHeaderBox.duration = swap;
+    swap = byterevers (0x00010000);
+    moov->MovieHeaderBox.rate = swap;
+    swap = byterevers (1);
     moov->MovieHeaderBox.volume = 1;
     moov->MovieHeaderBox.reserved=0;
     moov->MovieHeaderBox.reserved2[0] = 0;
     moov->MovieHeaderBox.reserved2[1] = 0;
-    moov->MovieHeaderBox.matrix[0] = 0x00010000;
+    swap = byterevers (0x00010000);
+    moov->MovieHeaderBox.matrix[0] = swap;
     moov->MovieHeaderBox.matrix[1] = 0;
     moov->MovieHeaderBox.matrix[2] = 0;
     moov->MovieHeaderBox.matrix[3] = 0;
-    moov->MovieHeaderBox.matrix[4] = 0x00010000;
+    moov->MovieHeaderBox.matrix[4] = swap;
     moov->MovieHeaderBox.matrix[5] = 0;
     moov->MovieHeaderBox.matrix[6] = 0;
-    moov->MovieHeaderBox.matrix[7] = 0;
+    moov->MovieHeaderBox.matrix[7] = 0;
+    swap = byterevers (0x40000000);
     moov->MovieHeaderBox.matrix[8] = 0x40000000;
     moov->MovieHeaderBox.pre_defined[0] = 0;
     moov->MovieHeaderBox.pre_defined[1] = 0;
@@ -194,173 +1029,19 @@
     moov->MovieHeaderBox.pre_defined[3] = 0;
     moov->MovieHeaderBox.pre_defined[4] = 0;
     moov->MovieHeaderBox.pre_defined[5] = 0;
-//    moov->MovieHeaderBox.next_track_ID = getnextID();
-    moov->MovieHeaderBox.next_track_ID = numtrack + 2;
+    //    moov->MovieHeaderBox.next_track_ID = getnextID();
+    swap = byterevers (totaltracks + 1);
+    moov->MovieHeaderBox.next_track_ID = swap;
+
+    //MovieBox
+    u32 sizeMOOV = sizeMVHD + sizeTRAK + sizePRCO + sizeRUCO + 8;
+    printf("Size moovie: %d, size trak: %d\n",sizeMOOV, sizeTRAK);
+    swap = byterevers (sizeMOOV); //Size movie: Taking into account number tracks
+    moov->size = swap;
+    swap = byterevers ('moov');
+    moov->type = swap;
 }
-
-void trackstructure (MovieBox *moov, int numtrack, int clock, namestrack namet){
-
-    //Track Header//
-    moov->TrackBox[numtrack].TrackHeaderBox.creation_time = clock;
-    moov->TrackBox[numtrack].TrackHeaderBox.modification_time = clock;
-    moov->TrackBox[numtrack].TrackHeaderBox.track_ID = numtrack + 1; //From 0x00000001 - 0x7FFFFFFF (dec 2147483647)
-    moov->TrackBox[numtrack].TrackHeaderBox.reserved = 0;
- //   moov->TrackBox[numtrack].TrackHeaderBox.duration = getdurationtrack();
-    moov->TrackBox[numtrack].TrackHeaderBox.reserved2[0] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.reserved2[1] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.layer = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.alternate_group = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.volume = 1;
-    moov->TrackBox[numtrack].TrackHeaderBox.reserved3 = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[0] = 0x00010000;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[1] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[2] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[3] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[4] = 0x00010000;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[5] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[6] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[7] = 0;
-    moov->TrackBox[numtrack].TrackHeaderBox.matrix[8] = 0x40000000;
-    moov->TrackBox[numtrack].TrackHeaderBox.width = 0; //just for video
-    moov->TrackBox[numtrack].TrackHeaderBox.height = 0; //just for video
-
-    //Track reference box
-    //No hint tracks at the moment.
-    moov->TrackBox[numtrack].TrackReferenceBox.reference_type = 'cdsc';
-    moov->TrackBox[numtrack].TrackReferenceBox.track_ID = numtrack + 1;
-
-  /*  //Edit list box
-    int entry_count,i;
-
-    entry_count = getentrycount();
-    for (i=1; i<entry_count; i++) {
-        moov->TrackBox[numtrack].EditListBox.segment_duration = 0;
-    }
-   */
-
-    //Media Box//
-
-    //Media Header Box//
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.creation_time = clock;
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.modification_time = clock;
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.timescale = 60;
-//    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.duration = getdurationtrack();
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language[0] = 'a';
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language[1] = 'n';
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.language[2] = 'g';
-    moov->TrackBox[numtrack].MediaBox.MediaHeaderBox.pre_defined = 0;
-
-    //Handler Box//
-    moov->TrackBox[numtrack].MediaBox.HandlerBox.pre_defined = 0;
-    //If we want to introduce another type of track change here:
-    moov->TrackBox[numtrack].MediaBox.HandlerBox.handler_type = 'soun';
-    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[0] = 0;
-    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[1] = 0;
-    moov->TrackBox[numtrack].MediaBox.HandlerBox.reserved[2] = 0;
-    //Use the name from Media Data Box to store it in HandlerBox.name:
-    strcpy(moov->TrackBox[numtrack].MediaBox.HandlerBox.name, namet[numtrack].title);
-
-    //Media Information Box//
-
-    //Sound Header Box //
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.balance = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox.reserved = 0;
-
-    //Hint Header Box//
-    //In case of hint track follow the box
-    /*moov->TrackBox[numtrack].MediaBox.MediaInformationBox.HintMediaHeaderBox.maxPDUsize = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.HintMediaHeaderBox.avgPDUsize = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.HintMediaHeaderBox.maxbitrate = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.HintMediaHeaderBox.avgbitrate = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.HintMediaHeaderBox.reserved = 0;
-    */
-
-    //Data information Box//
-    //In case we want add tracks located in the web
-
-    int flag = 1; // means that the media data is in the same file.No string, not even empty one
-                  //shall ve suplied in the entry field.
-
-    //If track is in URL add info here.
-    //Just admit URL data
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataEntryUrlBox.flags = 1;
-    if(flag == 0){
-        moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataEntryUrlBox.location = 0;
-        //moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataEntryUrnBox.name = 0;
-        //moov->TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox.DataEntryUrnBox.location = 0;
-    }
-
-   //el samplecontainer(moov, numtrack);
-
-}
-
-void samplecontainer(MovieBox *moov, int numtrack){
-
-    //Sample Table Box //
-    int numdatareferences = 0;
-
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[0] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[1] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[2] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[3] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[4] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.SampleEntry.reserved[5] = 0;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
-    SampleEntry.format = 'wav';
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
-    SampleEntry.data_reference_index = numdatareferences;  //Find more info
-    //No hinttrack at the moment.
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.HintSampleEntry.data = 0;
-
-    //BitRate
-
- //   moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
- //   BitRateBox.bufferSizeDB = sizetrack();
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.BitRateBox
-    .maxBitrate = 1411000; //In this case wav at 1441Kbps
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.BitRateBox
-    .avgBitrate = 1411000;
-
-    //Sample description box
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-    .SampleDescriptionBox.handler_type = 'soun'; //Just audio!
-
-    int i, entry;
-    entry=1;
-    moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-    .SampleDescriptionBox.entry_count = entry; //Check this later!!!
-
-    //No metadata and hint tracks, neither URI at the moment
-    for (i=0; i<=entry; i++) {
-        switch (moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .SampleDescriptionBox.handler_type) {
-            case 'soun': //For audio tracks
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.reserved[0] = 0;
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.reserved[1] = 0;
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.channelcount = 1; //The tracks are mono.
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.samplesize = 16;
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.pre_defined = 0;
-                //Ask Panos!!
-                moov->TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox
-                .AudioSampleEntry.samplerate = 441000; //44.1Khz
-                break;
-            case 'hint': //Hint tracks
-                //HintSampleEntry();
-                break;
-            case 'meta': //Metadata tracks
-               // MetadataSampleEntry();
-            default:
-            break;
-        }
-    }
-
-}
-
+/*
 void groupscontainer(MovieBox *moov){

     int num, flg, i, j, numelem;
@@ -416,108 +1097,8 @@
     }

 }
-
-void presetcontainer(MovieBox *moov){
-
-    int i, j, k, l, m, numpres=0, flag=0;
-    int num_output_channel = 2; // Stereo
-    char numelempres=0, prestype=0, namepres[30];
-    u16 globalvol=0, voltrack=0, num_updates =0 ;
-    char* fmt = "%[^\n]%*c";
-
-    printf("Define the number of presets: (10 max)\n");
-    scanf("%d",&numpres);
-    moov->PresetContainerBox.num_preset = numpres;
-    moov->PresetContainerBox.default_preset_ID = 0; // Indicates initial preset activated.
-    getchar();
-    fflush(stdin);
-    for (i=0; i<numpres; i++) {
-
-        printf("Enter name for the preset %d\n",i+1 );
-        fflush(stdin);
-        scanf(fmt,namepres);
-        strcpy(moov->PresetContainerBox.PresetBox[i].preset_name, namepres);
-
-        printf("Select mode of preset %s:\n",namepres);
-        printf("Mode |   Display  |   Edit\n");
-        printf("---- |   -------  |   -------\n");
-        printf(" 1   |   disable  |   disable\n");
-        printf(" 2   |   enable   |   disable\n");
-        printf(" 3   |   enable   |   enable\n");
-        scanf("%d",&flag);
-
-        moov->PresetContainerBox.PresetBox[i].preset_ID = numpres+1;
-
-        printf("Select type for preset %s:\n",namepres);
-        printf("preset_type |           Meaning\n");
-        printf("----------- |   ---------------------------\n");
-        printf("    0       |   static track volume preset\n");
-        printf("    1       |   static object volume preset\n");
-        printf("    2       |   dynamic track volume preset\n");
-        printf("    3       |   dynamic object volume preset\n");
-        //scanf(" %c", &prestype);
-        prestype = 0;
-        moov->PresetContainerBox.PresetBox[i].preset_type = prestype;
-
-        printf("Select the playback volume gain of preset output %d\n",i+1);
-        printf("   index     | 0 |  1  |  2  |  3  | ... | 149 | 150 |\n");
-        printf("value(ratio) | 0 |0.01 |0.02 |0.03 | ... |1.49 |1.50 |\n");
-        scanf("%d",&globalvol);
-        printf("Gloval volume %d\n",globalvol);
-        moov->PresetContainerBox.PresetBox[i].preset_global_volume = globalvol;
-
-        printf("Enter number of elements in the preset: (10 max)\n");
-        scanf(" %c", &numelempres);
-        moov->PresetContainerBox.PresetBox[i].num_preset_elements = numelempres;
-
-        moov->PresetContainerBox.PresetBox[i].preset_element_ID[j] = numelempres +1;
-
-        printf("Select the playback volume gain of element %d\n",k+1);
-        printf("   index     | 0 |  1  |  2  |  3  | ... | 199 | 200 |\n");
-        printf("value(ratio) | 0 |0.02 |0.04 |0.06 | ... |3.98 |4.00 |\n");
-        scanf("%d",&voltrack);
-
-        if(prestype == 0){
-            for (j=1; j<numelempres; j++) {
-                moov->PresetContainerBox.PresetBox[i].preset_volume_element[j] = voltrack;
-            }
-        }
-        if(prestype == 1){
-            moov->PresetContainerBox.PresetBox[i].num_input_channel[j] = 2; //All tracks stereo
-            moov->PresetContainerBox.PresetBox[i].output_channel_type = 2;
-            for (j=1; j<numelempres; j++) {
-                for (m=0; m<moov->PresetContainerBox.PresetBox[i].num_input_channel[j]; m++){
-                    for (k=0; k<num_output_channel; k++){
-                        moov->PresetContainerBox.PresetBox[i].preset_volume_element[j] = voltrack;
-                    }
-                }
-            }
-        }
-        if(prestype == 2){ // dynamic track volume preset
-            moov->PresetContainerBox.PresetBox[i].num_updates = num_updates; //No updates for the moment
-            for(l=0; l<num_updates; l++){
-                moov->PresetContainerBox.PresetBox[i].update_sample_number = 0;
-                for(j=0; j<numelempres; j++){
-                    moov->PresetContainerBox.PresetBox[i].preset_volume_element[j] = voltrack;
-                }
-            }
-        }
-        if(prestype == 3){             // dynamic object volume preset
-            moov->PresetContainerBox.PresetBox[i].num_updates = num_updates; //No updates for the moment
-            moov->PresetContainerBox.PresetBox[i].num_input_channel[j] = 2; //All tracks stereo
-            moov->PresetContainerBox.PresetBox[i].output_channel_type = 2;
-            for(l=0; l<num_updates; l++){
-                moov->PresetContainerBox.PresetBox[i].update_sample_number = 0;
-                for(j=0; j<numelempres; j++){
-                    for (k=0; k<num_output_channel; k++){
-                        moov->PresetContainerBox.PresetBox[i].preset_volume_element[j] = voltrack;
-                    }
-                }
-            }
-        }
-    }
-}
-
+*/
+/*
 void metadata(MetaBox *meta){

     int find = 0, i, j;
@@ -579,8 +1160,289 @@

     //Rest of the parameters
 }
+*/

+void writemoovbox(MovieBox moov, int numtrack,int totaltracks, FILE *imf){
+    //Write movie box//
+    fwrite(&moov.size, sizeof(u32), 1, imf);
+    fwrite(&moov.type, sizeof(u32), 1, imf);
+    //Movie header//
+    fwrite(&moov.MovieHeaderBox, sizeof(moov.MovieHeaderBox), 1, imf);
+    //Track container//
+    for (numtrack = 0; numtrack < totaltracks; numtrack++) {
+        fwrite(&moov.TrackBox[numtrack].size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].type, sizeof(u32), 1, imf);
+        //Trck header//
+        fwrite(&moov.TrackBox[numtrack].TrackHeaderBox,
+               sizeof(moov.TrackBox[numtrack].TrackHeaderBox), 1, imf);
+        //Media Box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.type, sizeof(u32), 1, imf);
+        //Media Header//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaHeaderBox,
+               sizeof(moov.TrackBox[numtrack].MediaBox.MediaHeaderBox), 1, imf);
+        //Handler Box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.pre_defined, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.handler_type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[0], sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[1], sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.reserved[2], sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[0], sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[1], sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[2], sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[3], sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.HandlerBox.data[4], sizeof(unsigned char), 1, imf);
+        //Media inforamtion box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.type, sizeof(u32), 1, imf);
+        //Sound media header//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SoundMediaHeaderBox,
+               sizeof(moov.TrackBox[numtrack].MediaBox.
+                      MediaInformationBox.SoundMediaHeaderBox), 1, imf);
+        //Data reference//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox,
+               sizeof(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.DataInformationBox), 1, imf);
+        //Sample table box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               type, sizeof(u32), 1, imf);
+
+        int i, swap, pos;
+        //Time to sample box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               TimeToSampleBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               TimeToSampleBox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               TimeToSampleBox.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               TimeToSampleBox.entry_count, sizeof(u32), 1, imf);
+
+        swap = byterevers(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                          TimeToSampleBox.entry_count);
+        pos = swap;
+
+        for (i=0; i<pos; i++) {
+
+            fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                   TimeToSampleBox.sample_count[i], sizeof(u32), 1, imf);
+            fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                   TimeToSampleBox.sample_delta[i], sizeof(u32), 1, imf);
+        }
+
+        //Sample description box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                SampleDescriptionBox.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                SampleDescriptionBox.entry_count, sizeof(u32), 1, imf);
+        //Audio Sample entry//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                SampleDescriptionBox.AudioSampleEntry.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.reserved[0], sizeof(unsigned char), 6, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.data_reference_index, sizeof(u16), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.reserved2[0], sizeof(u32), 2, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.channelcount, sizeof(u16), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.samplesize, sizeof(u16), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.reserved3, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.samplerate, sizeof(u32), 1, imf);
+        //ESDBox//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.version, sizeof(u32), 1, imf);
+        //ES Descriptor//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.tag
+               , sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.length
+               , sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.ES_ID
+               , sizeof(u16), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.mix
+               , sizeof(unsigned char), 1, imf);
+        //Decoder Config//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               tag, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               length, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               objectProfileInd, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               mix, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               maxBitRate, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               avgBitrate, sizeof(u32), 1, imf);
+/*        //DecoderSpecificInfo//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               DecoderSpecificInfo.tag, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               DecoderSpecificInfo.length, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               DecoderSpecificInfo.decSpecificInfoData[0], sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.DecoderConfigDescriptor.
+               DecoderSpecificInfo.decSpecificInfoData[1], sizeof(unsigned char), 1, imf);
+  */      //SLConfig//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor.
+               tag, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor.
+               length, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleDescriptionBox.AudioSampleEntry.ESbox.ES_Descriptor.SLConfigDescriptor.
+               predifined, sizeof(unsigned char), 1, imf);
+

+        //Sample Size box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleSizeBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleSizeBox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleSizeBox.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleSizeBox.sample_size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleSizeBox.sample_count, sizeof(u32), 1, imf);
+        swap = byterevers(moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                          SampleSizeBox.sample_count);
+        for(i=0; i<swap; i++){
+            fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+                   SampleSizeBox.entry_size[i], sizeof(u32), 1, imf);
+        }
+
+        //Sample to chunk box//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.entry_count, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.first_chunk, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.samples_per_chunk, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               SampleToChunk.sample_description_index, sizeof(u32), 1, imf);

+        //Chunk offset//
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               ChunkOffsetBox.size, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               ChunkOffsetBox.type, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               ChunkOffsetBox.version, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               ChunkOffsetBox.entry_count, sizeof(u32), 1, imf);
+        fwrite(&moov.TrackBox[numtrack].MediaBox.MediaInformationBox.SampleTableBox.
+               ChunkOffsetBox.chunk_offset[numtrack], sizeof(u32), 1, imf);
+    }
+
+    //Preset Container//
+    fwrite(&moov.PresetContainerBox.size, sizeof(u32), 1, imf);
+    fwrite(&moov.PresetContainerBox.type, sizeof(u32), 1, imf);
+    fwrite(&moov.PresetContainerBox.num_preset, sizeof(unsigned char), 1, imf);
+    fwrite(&moov.PresetContainerBox.default_preset_ID, sizeof(unsigned char), 1, imf);
+    //Preset Box
+    int j,i;
+    for (i=0; i<moov.PresetContainerBox.num_preset; i++) {
+        fwrite(&moov.PresetContainerBox.PresetBox[i].size, sizeof(u32), 1, imf);
+        fwrite(&moov.PresetContainerBox.PresetBox[i].type, sizeof(u32), 1, imf);
+        fwrite(&moov.PresetContainerBox.PresetBox[i].flags, sizeof(u32), 1, imf);
+        fwrite(&moov.PresetContainerBox.PresetBox[i].preset_ID, sizeof(unsigned char), 1, imf);
+        fwrite(&moov.PresetContainerBox.PresetBox[i].num_preset_elements,
+               sizeof(unsigned char), 1, imf);
+        for (j=0; j< moov.PresetContainerBox.PresetBox[i].num_preset_elements; j++) {
+            fwrite(&moov.PresetContainerBox.PresetBox[i].presElemId[j].
+                   preset_element_ID, sizeof(u32), 1, imf);
+        }
+        fwrite(&moov.PresetContainerBox.PresetBox[i].preset_type , sizeof(unsigned char), 1, imf);
+        fwrite(&moov.PresetContainerBox.PresetBox[i].preset_global_volume,
+               sizeof(unsigned char), 1, imf);
+        for (j=0; j< moov.PresetContainerBox.PresetBox[i].num_preset_elements; j++) {
+            fwrite(&moov.PresetContainerBox.PresetBox[i].presVolumElem[j].
+                    preset_volume_element,sizeof(unsigned char), 1, imf);
+        }
+        for (j=0; j<14; j++) {
+            fwrite(&moov.PresetContainerBox.PresetBox[i].preset_name[j], sizeof(char), 1, imf);
+        }
+    }
+
+    //Rules Container//
+    fwrite(&moov.RulesContainer.size, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.type, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.num_selection_rules, sizeof(u16), 1, imf);
+    fwrite(&moov.RulesContainer.num_mixing_rules, sizeof(u16), 1, imf);
+    //Selection Rules//
+    fwrite(&moov.RulesContainer.SelectionRules.size, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.SelectionRules.type, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.SelectionRules.version, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.SelectionRules.selection_rule_ID, sizeof(u16), 1, imf);
+    fwrite(&moov.RulesContainer.SelectionRules.selection_rule_type,
+            sizeof(unsigned char), 1, imf);
+    fwrite(&moov.RulesContainer.SelectionRules.element_ID, sizeof(u32), 1, imf);
+    for(i=0; i<14; i++){
+        fwrite(&moov.RulesContainer.SelectionRules.rule_description[i],
+                sizeof(char), 1, imf);
+    }
+    //Mixing Rules//
+    fwrite(&moov.RulesContainer.MixingRules.size, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.type, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.version, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.mixing_rule_ID, sizeof(u16), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.mixing_type,sizeof(unsigned char), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.element_ID, sizeof(u32), 1, imf);
+    fwrite(&moov.RulesContainer.MixingRules.key_elem_ID, sizeof(u32), 1, imf);
+    for(i=0; i<11; i++){
+        fwrite(&moov.RulesContainer.MixingRules.mix_description[i],
+               sizeof(char), 1, imf);
+    }
+
+}

+int byterevers(num){
+    int swapped;
+    swapped = ((num>>24)&0xff) | // move byte 3 to byte 0
+    ((num<<8)&0xff0000) | // move byte 1 to byte 2
+    ((num>>8)&0xff00) | // move byte 2 to byte 1
+    ((num<<24)&0xff000000); // byte 0 to byte 3
+    return swapped;
+}

+
+