fixed write animation flag & misleading layer[y,x] --> layer[x,y]

NotImplementedLife · NotImplementedLife · commit 6877d26202ac · 2021-03-15T17:02:09.000+02:00
diff --git a/PPMLib/PPMFile.cs b/PPMLib/PPMFile.cs
@@ -202,8 +202,7 @@ public static PPMFile Create(PPMAuthor author, List<PPMFrame> frames, byte[] aud
             uint animDataSize = (uint)(8 + 4 * frames.Count);
 
             file.AnimationFlags = 0x43;
-            file.FrameOffsetTableSize = (ushort)(4 * frames.Count);
-            file.AnimationFlags = BitConverter.ToUInt16(BitConverter.GetBytes(0x00430000), 0);
+            file.FrameOffsetTableSize = (ushort)(4 * frames.Count);            
 
             file.Frames = new PPMFrame[frames.Count];
             //SoundEffectFlags = new byte[frames.Count];
@@ -263,6 +262,7 @@ public void Save(string fn)
 
                 w.Write(FrameOffsetTableSize);
                 w.Write((uint)0); // 0x06A2
+                System.Diagnostics.Debug.WriteLine(AnimationFlags);
                 w.Write(AnimationFlags);
 
                 // Calculate frame offsets & write frame data
diff --git a/PPMLib/PPMFrame.cs b/PPMLib/PPMFrame.cs
@@ -33,9 +33,9 @@ public byte[] ToByteArray()
             return res.ToArray();
         }
 
-        private void L1PutLine(List<byte> lst, int ln)
+        private void L1PutLine(List<byte> lst, int y)
         {
-            int compr = (int)Layer1.LinesEncoding(ln);
+            int compr = (int)Layer1.LinesEncoding(y);
             if (compr == 0) return;
             if (compr == 1)
             {
@@ -45,7 +45,7 @@ private void L1PutLine(List<byte> lst, int ln)
                 {
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
-                        if (Layer1[ln, 8 * i + j])
+                        if (Layer1[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     if (chunk != 0x00)
                     {
@@ -68,7 +68,7 @@ private void L1PutLine(List<byte> lst, int ln)
                 {
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
-                        if (Layer1[ln, 8 * i + j])
+                        if (Layer1[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     if (chunk != 0xFF)
                     {
@@ -90,7 +90,7 @@ private void L1PutLine(List<byte> lst, int ln)
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
                     {
-                        if (Layer1[ln, 8 * i + j])
+                        if (Layer1[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     }
                     lst.Add(chunk);
@@ -99,9 +99,9 @@ private void L1PutLine(List<byte> lst, int ln)
             }
         }
 
-        private void L2PutLine(List<byte> lst, int ln)
+        private void L2PutLine(List<byte> lst, int y)
         {
-            int compr = (int)Layer2.LinesEncoding(ln);
+            int compr = (int)Layer2.LinesEncoding(y);
             if (compr == 0) return;
             if (compr == 1)
             {
@@ -111,7 +111,7 @@ private void L2PutLine(List<byte> lst, int ln)
                 {
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
-                        if (Layer2[ln, 8 * i + j])
+                        if (Layer2[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     if (chunk != 0x00)
                     {
@@ -134,7 +134,7 @@ private void L2PutLine(List<byte> lst, int ln)
                 {
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
-                        if (Layer2[ln, 8 * i + j])
+                        if (Layer2[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     if (chunk != 0xFF)
                     {
@@ -156,7 +156,7 @@ private void L2PutLine(List<byte> lst, int ln)
                     byte chunk = 0;
                     for (int j = 0; j < 8; j++)
                     {
-                        if (Layer2[ln, 8 * i + j])
+                        if (Layer2[8 * i + j, y]) 
                             chunk |= (byte)(1 << j);
                     }
                     lst.Add(chunk);
diff --git a/PPMLib/PPMLayer.cs b/PPMLib/PPMLayer.cs
@@ -29,20 +29,20 @@ public void setLinesEncoding(int lineIndex, LineEncoding value)
         /// <summary>
         /// Set the line encoding for the whole layer
         /// </summary>
-        /// <param name="index">Line Index</param>
+        /// <param name="y">Line Index</param>
         /// <returns>New encoding type for the line</returns>
-        public LineEncoding SetLineEncodingForWholeLayer(int index) // Set?
+        public LineEncoding SetLineEncodingForWholeLayer(int y) // Set?
         {
             var _0chks = 0;
             var _1chks = 0;
             for (var x = 0; x <= 32; x++)
             {
-                var c = 8 * index;
+                var c = 8 * y;
                 var n0 = 0;
                 var n1 = 0;
                 for (var x_ = 0; x_ <= 8; x_++)
                 {
-                    if (this[index, c + x_])
+                    if (this[c + x_, y])
                     {
                         n1 += 1;
                     }
@@ -72,11 +72,11 @@ public LineEncoding SetLineEncodingForWholeLayer(int index) // Set?
         /// Insert a line in current layer
         /// </summary>
         /// <param name="lineData">Line Data</param>
-        /// <param name="index">Index Of Line</param>
-        private void InsertLineInLayer(List<byte> lineData, int index)
+        /// <param name="y">Index Of Line</param>
+        private void InsertLineInLayer(List<byte> lineData, int y)
         {
             List<byte> chks = new List<byte>();
-            switch (LinesEncoding(index))
+            switch (LinesEncoding(y))
             {
                 case 0:
                     {
@@ -91,12 +91,12 @@ private void InsertLineInLayer(List<byte> lineData, int index)
                             byte chunk = 0;
                             for (var x_ = 0; x_ <= 8; x_++)
                             {
-                                if (this[index, 8 * x + x_])
+                                if (this[8 * x + x_, y]) 
                                 {
                                     chunk = (byte)(chunk | (byte)(1 << x_));
                                 }
                             }
-                            if (chunk != ((LinesEncoding(index) == (PPMLib.LineEncoding)1) ? 0x0 : 0xFF))
+                            if (chunk != ((LinesEncoding(y) == (PPMLib.LineEncoding)1) ? 0x0 : 0xFF))
                             {
                                 flag |= (1U << (31 - x));
                                 chks.Add(chunk);
@@ -116,7 +116,7 @@ private void InsertLineInLayer(List<byte> lineData, int index)
                             byte chunk = 0;
                             for (var x_ = 0; x_ <= 8; x_++)
                             {
-                                if (this[index, 8 * x + x_])
+                                if (this[8 * x + x_, y]) 
                                 {
                                     chunk = (byte)(chunk | (byte)(1 << x_));
                                 }
@@ -150,7 +150,7 @@ public byte this[int p]
             set => _layerData[p] = value;
         }
 
-        public bool this[int y, int x]
+        public bool this[int x, int y]
         {
             get
             {
diff --git a/PPMLib/WPF/PPMRenderer.cs b/PPMLib/WPF/PPMRenderer.cs
@@ -97,7 +97,7 @@ public static WriteableBitmap GetFrameBitmap(PPMFrame frame)
             {
                 for (int y = 0; y < 192; y++)
                 {
-                    if (frame.Layer1[y, x]) 
+                    if (frame.Layer1[x, y]) 
                     {
                         int b = 256 * y + x;
                         int p = 3 - b % 4;
@@ -111,7 +111,7 @@ public static WriteableBitmap GetFrameBitmap(PPMFrame frame)
             {
                 for (int y = 0; y < 192; y++)
                 {
-                    if (frame.Layer2[y, x])
+                    if (frame.Layer2[x, y]) 
                     {
                         int b = 256 * y + x;
                         int p = 3 - b % 4;
diff --git a/PPMLib/Winforms/PPMRenderer.cs b/PPMLib/Winforms/PPMRenderer.cs
@@ -94,7 +94,7 @@ public static Bitmap GetFrameBitmap(PPMFrame frame)
             {
                 for (var x = 0; x <= 255; x++)
                 {
-                    if (frame.Layer1[y, x])
+                    if (frame.Layer1[x, y]) 
                     {
                         if (frame.Layer1.PenColor != PenColor.Inverted)
                         {
@@ -107,7 +107,7 @@ public static Bitmap GetFrameBitmap(PPMFrame frame)
                     }
                     else
                     {
-                        if (frame.Layer2[y, x])
+                        if (frame.Layer2[x, y]) 
                         {
                             if (frame.Layer2.PenColor != PenColor.Inverted)
                             {

Original file line number	Diff line number	Diff line change
`@@ -33,9 +33,9 @@ public byte[] ToByteArray()`
`33`	`33`	`return res.ToArray();`
`34`	`34`	`}`
`35`	`35`
`36`		`- private void L1PutLine(List<byte> lst, int ln)`
	`36`	`+ private void L1PutLine(List<byte> lst, int y)`
`37`	`37`	`{`
`38`		`- int compr = (int)Layer1.LinesEncoding(ln);`
	`38`	`+ int compr = (int)Layer1.LinesEncoding(y);`
`39`	`39`	`if (compr == 0) return;`
`40`	`40`	`if (compr == 1)`
`41`	`41`	`{`
`@@ -45,7 +45,7 @@ private void L1PutLine(List<byte> lst, int ln)`
`45`	`45`	`{`
`46`	`46`	`byte chunk = 0;`
`47`	`47`	`for (int j = 0; j < 8; j++)`
`48`		`- if (Layer1[ln, 8 * i + j])`
	`48`	`+ if (Layer1[8 * i + j, y])`
`49`	`49`	`chunk \|= (byte)(1 << j);`
`50`	`50`	`if (chunk != 0x00)`
`51`	`51`	`{`
`@@ -68,7 +68,7 @@ private void L1PutLine(List<byte> lst, int ln)`
`68`	`68`	`{`
`69`	`69`	`byte chunk = 0;`
`70`	`70`	`for (int j = 0; j < 8; j++)`
`71`		`- if (Layer1[ln, 8 * i + j])`
	`71`	`+ if (Layer1[8 * i + j, y])`
`72`	`72`	`chunk \|= (byte)(1 << j);`
`73`	`73`	`if (chunk != 0xFF)`
`74`	`74`	`{`
`@@ -90,7 +90,7 @@ private void L1PutLine(List<byte> lst, int ln)`
`90`	`90`	`byte chunk = 0;`
`91`	`91`	`for (int j = 0; j < 8; j++)`
`92`	`92`	`{`
`93`		`- if (Layer1[ln, 8 * i + j])`
	`93`	`+ if (Layer1[8 * i + j, y])`
`94`	`94`	`chunk \|= (byte)(1 << j);`
`95`	`95`	`}`
`96`	`96`	`lst.Add(chunk);`
`@@ -99,9 +99,9 @@ private void L1PutLine(List<byte> lst, int ln)`
`99`	`99`	`}`
`100`	`100`	`}`
`101`	`101`
`102`		`- private void L2PutLine(List<byte> lst, int ln)`
	`102`	`+ private void L2PutLine(List<byte> lst, int y)`
`103`	`103`	`{`
`104`		`- int compr = (int)Layer2.LinesEncoding(ln);`
	`104`	`+ int compr = (int)Layer2.LinesEncoding(y);`
`105`	`105`	`if (compr == 0) return;`
`106`	`106`	`if (compr == 1)`
`107`	`107`	`{`
`@@ -111,7 +111,7 @@ private void L2PutLine(List<byte> lst, int ln)`
`111`	`111`	`{`
`112`	`112`	`byte chunk = 0;`
`113`	`113`	`for (int j = 0; j < 8; j++)`
`114`		`- if (Layer2[ln, 8 * i + j])`
	`114`	`+ if (Layer2[8 * i + j, y])`
`115`	`115`	`chunk \|= (byte)(1 << j);`
`116`	`116`	`if (chunk != 0x00)`
`117`	`117`	`{`
`@@ -134,7 +134,7 @@ private void L2PutLine(List<byte> lst, int ln)`
`134`	`134`	`{`
`135`	`135`	`byte chunk = 0;`
`136`	`136`	`for (int j = 0; j < 8; j++)`
`137`		`- if (Layer2[ln, 8 * i + j])`
	`137`	`+ if (Layer2[8 * i + j, y])`
`138`	`138`	`chunk \|= (byte)(1 << j);`
`139`	`139`	`if (chunk != 0xFF)`
`140`	`140`	`{`
`@@ -156,7 +156,7 @@ private void L2PutLine(List<byte> lst, int ln)`
`156`	`156`	`byte chunk = 0;`
`157`	`157`	`for (int j = 0; j < 8; j++)`
`158`	`158`	`{`
`159`		`- if (Layer2[ln, 8 * i + j])`
	`159`	`+ if (Layer2[8 * i + j, y])`
`160`	`160`	`chunk \|= (byte)(1 << j);`
`161`	`161`	`}`
`162`	`162`	`lst.Add(chunk);`
Original file line number	Diff line number	Diff line change
`@@ -29,20 +29,20 @@ public void setLinesEncoding(int lineIndex, LineEncoding value)`
`29`	`29`	`/// <summary>`
`30`	`30`	`/// Set the line encoding for the whole layer`
`31`	`31`	`/// </summary>`
`32`		`- /// <param name="index">Line Index</param>`
	`32`	`+ /// <param name="y">Line Index</param>`
`33`	`33`	`/// <returns>New encoding type for the line</returns>`
`34`		`- public LineEncoding SetLineEncodingForWholeLayer(int index) // Set?`
	`34`	`+ public LineEncoding SetLineEncodingForWholeLayer(int y) // Set?`
`35`	`35`	`{`
`36`	`36`	`var _0chks = 0;`
`37`	`37`	`var _1chks = 0;`
`38`	`38`	`for (var x = 0; x <= 32; x++)`
`39`	`39`	`{`
`40`		`- var c = 8 * index;`
	`40`	`+ var c = 8 * y;`
`41`	`41`	`var n0 = 0;`
`42`	`42`	`var n1 = 0;`
`43`	`43`	`for (var x_ = 0; x_ <= 8; x_++)`
`44`	`44`	`{`
`45`		`- if (this[index, c + x_])`
	`45`	`+ if (this[c + x_, y])`
`46`	`46`	`{`
`47`	`47`	`n1 += 1;`
`48`	`48`	`}`
`@@ -72,11 +72,11 @@ public LineEncoding SetLineEncodingForWholeLayer(int index) // Set?`
`72`	`72`	`/// Insert a line in current layer`
`73`	`73`	`/// </summary>`
`74`	`74`	`/// <param name="lineData">Line Data</param>`
`75`		`- /// <param name="index">Index Of Line</param>`
`76`		`- private void InsertLineInLayer(List<byte> lineData, int index)`
	`75`	`+ /// <param name="y">Index Of Line</param>`
	`76`	`+ private void InsertLineInLayer(List<byte> lineData, int y)`
`77`	`77`	`{`
`78`	`78`	`List<byte> chks = new List<byte>();`
`79`		`- switch (LinesEncoding(index))`
	`79`	`+ switch (LinesEncoding(y))`
`80`	`80`	`{`
`81`	`81`	`case 0:`
`82`	`82`	`{`
`@@ -91,12 +91,12 @@ private void InsertLineInLayer(List<byte> lineData, int index)`
`91`	`91`	`byte chunk = 0;`
`92`	`92`	`for (var x_ = 0; x_ <= 8; x_++)`
`93`	`93`	`{`
`94`		`- if (this[index, 8 * x + x_])`
	`94`	`+ if (this[8 * x + x_, y])`
`95`	`95`	`{`
`96`	`96`	`chunk = (byte)(chunk \| (byte)(1 << x_));`
`97`	`97`	`}`
`98`	`98`	`}`
`99`		`- if (chunk != ((LinesEncoding(index) == (PPMLib.LineEncoding)1) ? 0x0 : 0xFF))`
	`99`	`+ if (chunk != ((LinesEncoding(y) == (PPMLib.LineEncoding)1) ? 0x0 : 0xFF))`
`100`	`100`	`{`
`101`	`101`	`flag \|= (1U << (31 - x));`
`102`	`102`	`chks.Add(chunk);`
`@@ -116,7 +116,7 @@ private void InsertLineInLayer(List<byte> lineData, int index)`
`116`	`116`	`byte chunk = 0;`
`117`	`117`	`for (var x_ = 0; x_ <= 8; x_++)`
`118`	`118`	`{`
`119`		`- if (this[index, 8 * x + x_])`
	`119`	`+ if (this[8 * x + x_, y])`
`120`	`120`	`{`
`121`	`121`	`chunk = (byte)(chunk \| (byte)(1 << x_));`
`122`	`122`	`}`
`@@ -150,7 +150,7 @@ public byte this[int p]`
`150`	`150`	`set => _layerData[p] = value;`
`151`	`151`	`}`
`152`	`152`
`153`		`- public bool this[int y, int x]`
	`153`	`+ public bool this[int x, int y]`
`154`	`154`	`{`
`155`	`155`	`get`
`156`	`156`	`{`
Original file line number	Diff line number	Diff line change
`@@ -97,7 +97,7 @@ public static WriteableBitmap GetFrameBitmap(PPMFrame frame)`
`97`	`97`	`{`
`98`	`98`	`for (int y = 0; y < 192; y++)`
`99`	`99`	`{`
`100`		`- if (frame.Layer1[y, x])`
	`100`	`+ if (frame.Layer1[x, y])`
`101`	`101`	`{`
`102`	`102`	`int b = 256 * y + x;`
`103`	`103`	`int p = 3 - b % 4;`
`@@ -111,7 +111,7 @@ public static WriteableBitmap GetFrameBitmap(PPMFrame frame)`
`111`	`111`	`{`
`112`	`112`	`for (int y = 0; y < 192; y++)`
`113`	`113`	`{`
`114`		`- if (frame.Layer2[y, x])`
	`114`	`+ if (frame.Layer2[x, y])`
`115`	`115`	`{`
`116`	`116`	`int b = 256 * y + x;`
`117`	`117`	`int p = 3 - b % 4;`
Original file line number	Diff line number	Diff line change
`@@ -94,7 +94,7 @@ public static Bitmap GetFrameBitmap(PPMFrame frame)`
`94`	`94`	`{`
`95`	`95`	`for (var x = 0; x <= 255; x++)`
`96`	`96`	`{`
`97`		`- if (frame.Layer1[y, x])`
	`97`	`+ if (frame.Layer1[x, y])`
`98`	`98`	`{`
`99`	`99`	`if (frame.Layer1.PenColor != PenColor.Inverted)`
`100`	`100`	`{`
`@@ -107,7 +107,7 @@ public static Bitmap GetFrameBitmap(PPMFrame frame)`
`107`	`107`	`}`
`108`	`108`	`else`
`109`	`109`	`{`
`110`		`- if (frame.Layer2[y, x])`
	`110`	`+ if (frame.Layer2[x, y])`
`111`	`111`	`{`
`112`	`112`	`if (frame.Layer2.PenColor != PenColor.Inverted)`
`113`	`113`	`{`