Add a helper function for getting the super prototype of an object.

diff --git a/Atom.js b/Atom.js
index 7d15c3e2cf47579c14794fe3781b6f0a3f655cc1..52e9e59ab28031776fb70bf6bd4c89993c166f1a 100644 (file)
--- a/Atom.js
+++ b/Atom.js
@@ -38,6 +38,10 @@ Atom.create = function(buffer, offset) {
     }
 }
 
     }
 }
 

+Atom.prototype.super = function(object) {
+    return Object.getPrototypeOf(object.prototype);
+}
+

 Atom.prototype.setDefaults = function() {
     Object.defineProperty(this, "is64bit", {
             value: false,
 Atom.prototype.setDefaults = function() {
     Object.defineProperty(this, "is64bit", {
             value: false,


@@ -133,13 +137,13 @@ Atom.prototype.getAtomsByType = function(type) {
 };
 
 var FileTypeAtom = function(buffer, offset) {
 };
 
 var FileTypeAtom = function(buffer, offset) {

-    Object.getPrototypeOf(FileTypeAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(FileTypeAtom).constructor.call(this, buffer, offset);

 }
 
 FileTypeAtom.prototype = Object.create(Atom.prototype);
 
 FileTypeAtom.prototype.setDefaults = function() {
 }
 
 FileTypeAtom.prototype = Object.create(Atom.prototype);
 
 FileTypeAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(FileTypeAtom.prototype).setDefaults.call(this);
+    this.super(FileTypeAtom).setDefaults.call(this);

     this.minimumSize = 16;
     this.brand = "";
     this.version = 0;
     this.minimumSize = 16;
     this.brand = "";
     this.version = 0;


@@ -147,7 +151,7 @@ FileTypeAtom.prototype.setDefaults = function() {
 }
 
 FileTypeAtom.prototype.parse = function(buffer, offset) {
 }
 
 FileTypeAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(FileTypeAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(FileTypeAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -170,18 +174,18 @@ FileTypeAtom.prototype.parse = function(buffer, offset) {
 }
 
 var ContainerAtom = function(buffer, offset) {
 }
 
 var ContainerAtom = function(buffer, offset) {

-    Object.getPrototypeOf(ContainerAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(ContainerAtom).constructor.call(this, buffer, offset);

 }
 
 ContainerAtom.prototype = Object.create(Atom.prototype);
 
 ContainerAtom.prototype.setDefaults = function() {
 }
 
 ContainerAtom.prototype = Object.create(Atom.prototype);
 
 ContainerAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(ContainerAtom.prototype).setDefaults.call(this);
+    this.super(ContainerAtom).setDefaults.call(this);

     this.childAtoms = [];
 }
 
 ContainerAtom.prototype.parse = function(buffer, offset) {
     this.childAtoms = [];
 }
 
 ContainerAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(ContainerAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(ContainerAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -196,19 +200,19 @@ ContainerAtom.prototype.parse = function(buffer, offset) {
 }
 
 var VersionFlagsAtom = function(buffer, offset) {
 }
 
 var VersionFlagsAtom = function(buffer, offset) {

-    Object.getPrototypeOf(VersionFlagsAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(VersionFlagsAtom).constructor.call(this, buffer, offset);

 }
 
 VersionFlagsAtom.prototype = Object.create(Atom.prototype);
 
 VersionFlagsAtom.prototype.setDefaults = function() {
 }
 
 VersionFlagsAtom.prototype = Object.create(Atom.prototype);
 
 VersionFlagsAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(VersionFlagsAtom.prototype).setDefaults.call(this);
+    this.super(VersionFlagsAtom).setDefaults.call(this);

     this.version = 0;
     this.flags = 0;
 }
 
 VersionFlagsAtom.prototype.parse = function(buffer, offset) {
     this.version = 0;
     this.flags = 0;
 }
 
 VersionFlagsAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(VersionFlagsAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(VersionFlagsAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -225,13 +229,13 @@ VersionFlagsAtom.prototype.parse = function(buffer, offset) {
 }
 
 var MovieHeaderAtom = function(buffer, offset) {
 }
 
 var MovieHeaderAtom = function(buffer, offset) {

-    return Object.getPrototypeOf(MovieHeaderAtom.prototype).constructor.call(this, buffer, offset);
+    return this.super(MovieHeaderAtom).constructor.call(this, buffer, offset);

 }
 
 MovieHeaderAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 MovieHeaderAtom.prototype.setDefaults = function() {
 }
 
 MovieHeaderAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 MovieHeaderAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(MovieHeaderAtom.prototype).setDefaults.call(this);
+    this.super(MovieHeaderAtom).setDefaults.call(this);

     this.creationTime = 0;
     this.modificationTime = 0;
     this.timeScale = 0;
     this.creationTime = 0;
     this.modificationTime = 0;
     this.timeScale = 0;


@@ -247,7 +251,7 @@ MovieHeaderAtom.prototype.setDefaults = function() {
 }
 
 MovieHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 MovieHeaderAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(MovieHeaderAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(MovieHeaderAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -325,13 +329,13 @@ MovieHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 var TrackHeaderAtom = function(buffer, offset) {
 }
 
 var TrackHeaderAtom = function(buffer, offset) {

-    Object.getPrototypeOf(TrackHeaderAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(TrackHeaderAtom).constructor.call(this, buffer, offset);

 }
 
 TrackHeaderAtom.prototype = Object.create(Atom.prototype);
 
 TrackHeaderAtom.prototype.setDefaults = function() {
 }
 
 TrackHeaderAtom.prototype = Object.create(Atom.prototype);
 
 TrackHeaderAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(TrackHeaderAtom.prototype).setDefaults.call(this);
+    this.super(TrackHeaderAtom).setDefaults.call(this);

 
     this.creationTime = 0;
     this.modificationTime = 0;
 
     this.creationTime = 0;
     this.modificationTime = 0;


@@ -346,7 +350,7 @@ TrackHeaderAtom.prototype.setDefaults = function() {
 }
 
 TrackHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 TrackHeaderAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(TrackHeaderAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(TrackHeaderAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -421,13 +425,13 @@ TrackHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 var MediaHeaderAtom = function(buffer, offset) {
 }
 
 var MediaHeaderAtom = function(buffer, offset) {

-    Object.getPrototypeOf(MediaHeaderAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(MediaHeaderAtom).constructor.call(this, buffer, offset);

 }
 
 MediaHeaderAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 MediaHeaderAtom.prototype.setDefaults = function() {
 }
 
 MediaHeaderAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 MediaHeaderAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(MediaHeaderAtom.prototype).setDefaults.call(this);
+    this.super(MediaHeaderAtom).setDefaults.call(this);

 
     this.creationTime = 0;
     this.modificationTime = 0;
 
     this.creationTime = 0;
     this.modificationTime = 0;


@@ -438,7 +442,7 @@ MediaHeaderAtom.prototype.setDefaults = function() {
 }
 
 MediaHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 MediaHeaderAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(MediaHeaderAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(MediaHeaderAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -464,13 +468,13 @@ MediaHeaderAtom.prototype.parse = function(buffer, offset) {
 }
 
 var SyncSampleAtom = function(buffer, offset) {
 }
 
 var SyncSampleAtom = function(buffer, offset) {

-    Object.getPrototypeOf(SyncSampleAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(SyncSampleAtom).constructor.call(this, buffer, offset);

 }
 
 SyncSampleAtom.prototype = Object.create(Atom.prototype);
 
 SyncSampleAtom.prototype.setDefaults = function() {
 }
 
 SyncSampleAtom.prototype = Object.create(Atom.prototype);
 
 SyncSampleAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(SyncSampleAtom.prototype).setDefaults.call(this);
+    this.super(SyncSampleAtom).setDefaults.call(this);

 
     this.version = 0;
     this.flags = 0;
 
     this.version = 0;
     this.flags = 0;


@@ -479,7 +483,7 @@ SyncSampleAtom.prototype.setDefaults = function() {
 }
 
 SyncSampleAtom.prototype.parse = function(buffer, offset) {
 }
 
 SyncSampleAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(SyncSampleAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(SyncSampleAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 


@@ -503,13 +507,13 @@ SyncSampleAtom.prototype.parse = function(buffer, offset) {
 }
 
 var TimeToSampleAtom = function(buffer, offset) {
 }
 
 var TimeToSampleAtom = function(buffer, offset) {

-    Object.getPrototypeOf(TimeToSampleAtom.prototype).constructor.call(this, buffer, offset);
+    this.super(TimeToSampleAtom).constructor.call(this, buffer, offset);

 }
 
 TimeToSampleAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 TimeToSampleAtom.prototype.setDefaults = function() {
 }
 
 TimeToSampleAtom.prototype = Object.create(VersionFlagsAtom.prototype);
 
 TimeToSampleAtom.prototype.setDefaults = function() {

-    Object.getPrototypeOf(TimeToSampleAtom.prototype).setDefaults.call(this);
+    this.super(TimeToSampleAtom).setDefaults.call(this);

 
     this.entries = 0;
     
 
     this.entries = 0;
     


@@ -522,7 +526,7 @@ TimeToSampleAtom.prototype.setDefaults = function() {
 }
 
 TimeToSampleAtom.prototype.parse = function(buffer, offset) {
 }
 
 TimeToSampleAtom.prototype.parse = function(buffer, offset) {

-    var headerOffset = Object.getPrototypeOf(TimeToSampleAtom.prototype).parse.call(this, buffer, offset);
+    var headerOffset = this.super(TimeToSampleAtom).parse.call(this, buffer, offset);

     if (!headerOffset)
         return 0;
 
     if (!headerOffset)
         return 0;
 

diff --git a/AtomTester.html b/AtomTester.html
index 04199880eaf42f8b2120f540b5b397d14016d519..d0bcbf133020e5d26f5e630ddd3b8789e1edbbfb 100644 (file)
--- a/AtomTester.html
+++ b/AtomTester.html
@@ -3,26 +3,61 @@
     <title>AtomTester</title>
     <script src=Atom.js></script>
     <script>
     <title>AtomTester</title>
     <script src=Atom.js></script>
     <script>

-        var atoms = [];
+        var moovAtom;

         function onFileSelect(e) {
             var file = e.target.files[0];
             var reader = new FileReader();
         function onFileSelect(e) {
             var file = e.target.files[0];
             var reader = new FileReader();

-            reader.onload = (function(file) {
-                return function(e) {
-                    var offset = 0;
+            output.innerHTML = '';
+            
+            function checkForMoovAtom(offset) {
+                reader.onload = function(e) {
+                    var result = e.target.result;
+                    var basicAtom = new Atom(result);
+                    if (!basicAtom)
+                        return;
+                    else if (basicAtom.type == 'moov') 
+                        readMoovAtom(offset, basicAtom.size);
+                    else
+                        checkForMoovAtom(offset + basicAtom.size);
+                };
+                var subset = file.webkitSlice(offset, offset + 16);
+                reader.readAsArrayBuffer(subset);
+            };
+            
+            function readMoovAtom(offset, length) {
+                reader.onload = function(e) { 
+                    moovAtom = Atom.create(e.target.result);

                     var output = document.getElementById('output');
                     var output = document.getElementById('output');

-                    output.innerHTML = '';
-                    while (offset < e.target.result.byteLength) {
-                        var atom = Atom.create(e.target.result, offset);
-                        if (!atom)
-                            break;
-                        atoms.push(atom);
-                        output.appendChild(toDOMNode(atom));
-                        offset += atom.size;
-                    }
+                    output.appendChild(toDOMNode(moovAtom));

                 };
                 };

-            })(file);
-            reader.readAsArrayBuffer(file);
+                var subset = file.webkitSlice(offset, offset + length);
+                reader.readAsArrayBuffer(subset);
+            };
+            
+            checkForMoovAtom(0);
+        }
+        
+        function toDOMRepresentation(object)
+        {
+            if (object instanceof Atom)
+                return toDOMNode(object);
+            else if (object instanceof Array) {
+                var span = document.createElement('span');
+                span.appendChild(document.createTextNode('['));
+                for (var i = 0; i < object.length; ++i) {
+                    span.appendChild(toDOMRepresentation(object[i]));
+                    if (i + 1 < object.length)
+                        span.appendChild(document.createTextNode(', '));
+                }
+                span.appendChild(document.createTextNode(']'));
+                return span;
+            }
+            else if (typeof(object) == "string")
+                return document.createTextNode('"' + object + '"');
+            else if (object instanceof Date)
+                return document.createTextNode(object.toLocaleString());
+            else
+                return document.createTextNode(object.toString());

         }
         
         function toDOMNode(object)
         }
         
         function toDOMNode(object)


@@ -36,20 +71,8 @@
                 var div = document.createElement('div');
                 var dt = document.createElement('dt');
                 dt.innerText = property;
                 var div = document.createElement('div');
                 var dt = document.createElement('dt');
                 dt.innerText = property;

-

                 var dd = document.createElement('dd');
                 var dd = document.createElement('dd');

-                if (value instanceof Atom)
-                    dd.appendChild(toDOMNode(value));
-                else if (value instanceof Array) {
-                    dd.appendChild(toDOMNode(value));
-                }
-                else if (typeof(value) == "string")
-                    dd.innerText = '"' + value + '"';
-                else if (value instanceof Date)
-                    dd.innerText = value.toLocaleString();
-                else
-                    dd.innerText = value;
-
+                dd.appendChild(toDOMRepresentation(value));

                 div.appendChild(dt);
                 div.appendChild(dd);
                 output.appendChild(div);
                 div.appendChild(dt);
                 div.appendChild(dd);
                 output.appendChild(div);


@@ -62,16 +85,22 @@
         }
     </script>
     <style>
         }
     </script>
     <style>

-        dl { border: 1px solid black; }
+        dl { border: 1px solid black; padding: 1px; }

         dt, dd { display: inline; }
         dt:after { content:": " }
         dd:after { content:"\A"; white-space:pre; }
         dd dl { margin: 0; vertical-align: top }
         dt, dd { display: inline; }
         dt:after { content:": " }
         dd:after { content:"\A"; white-space:pre; }
         dd dl { margin: 0; vertical-align: top }

+        dd span { display: inline-block; vertical-align: top; }
+
+        dt, dd { display: inline-block; min-width: 8em; }
+        dd { margin-left: 1em; }

         
         /* make the output display as a table */
         
         /* make the output display as a table */

+        /*

         dl { display: table; }
         dl div { display: table-row; }
         dt, dd { display: table-cell; }
         dl { display: table; }
         dl div { display: table-row; }
         dt, dd { display: table-cell; }

+        */

     </style>
 </head>
 <body id="atomtester" onload="setup()">
     </style>
 </head>
 <body id="atomtester" onload="setup()">