Index: src/TagLib/Id3v2/Tag.cs
===================================================================
--- src/TagLib/Id3v2/Tag.cs	(revision 121360)
+++ src/TagLib/Id3v2/Tag.cs	(working copy)
@@ -826,7 +826,7 @@
 		{
 			if (data == null)
 				throw new ArgumentNullException ("data");
-			
+
 			// If the entire tag is marked as unsynchronized,
 			// resynchronize it.
 			
@@ -871,7 +871,8 @@
 				try {
 					frame = FrameFactory.CreateFrame (data,
 						ref frame_data_position,
-						header.MajorVersion);
+						header.MajorVersion,
+                        (header.Flags & HeaderFlags.Unsynchronisation) != 0);
 				} catch (NotImplementedException) {
 					continue;
 				}
Index: src/TagLib/Id3v2/FrameFactory.cs
===================================================================
--- src/TagLib/Id3v2/FrameFactory.cs	(revision 121360)
+++ src/TagLib/Id3v2/FrameFactory.cs	(working copy)
@@ -112,6 +112,10 @@
 		///    A <see cref="byte" /> value specifying the ID3v2 version
 		///    the frame in <paramref name="data"/> is encoded in.
 		/// </param>
+		/// <param name="alreadyUnsynched">
+		///    A <see cref="bool" /> value specifying whether the entire
+		///    tag has already been unsynchronized.
+		/// </param>
 		/// <returns>
 		///    A <see cref="Frame" /> object read from the data, or <see
 		///    langword="null" /> if none is found.
@@ -121,7 +125,7 @@
 		///    converted to ID3v2 or uses encryption or compression.
 		/// </exception>
 		public static Frame CreateFrame (ByteVector data,
-		                                 ref int offset, byte version)
+		                                 ref int offset, byte version, bool alreadyUnsynched)
 		{
 			int position = offset;
 			
@@ -140,6 +144,12 @@
 						(c < '1' || c > '9'))
 						return null;
 			}
+
+            if (alreadyUnsynched) {
+                // Mark the frame as not Unsynchronozed because the entire
+                // tag has already been Unsynchronized
+                header.Flags &= ~FrameFlags.Unsynchronisation;
+            }
 			
 			// Windows Media Player may create zero byte frames.
 			// Just send them off as unknown and delete them.
Index: src/TagLib/Id3v2/FrameHeader.cs
===================================================================
--- src/TagLib/Id3v2/FrameHeader.cs	(revision 121360)
+++ src/TagLib/Id3v2/FrameHeader.cs	(working copy)
@@ -76,7 +76,7 @@
 		/// <summary>
 		///    Indicates that the frame data has been unsynchronized.
 		/// </summary>
-		Unsychronisation = 0x0002,
+		Unsynchronisation = 0x0002,
 		
 		/// <summary>
 		///    Indicates that the frame has a data length indicator.
Index: src/TagLib/Id3v2/Frame.cs
===================================================================
--- src/TagLib/Id3v2/Frame.cs	(revision 121360)
+++ src/TagLib/Id3v2/Frame.cs	(working copy)
@@ -240,7 +240,7 @@
 			// of ID3v2.
 			if (version < 4)
 				Flags &= ~(FrameFlags.DataLengthIndicator |
-					FrameFlags.Unsychronisation);
+					FrameFlags.Unsynchronisation);
 			
 			if (version < 3)
 				Flags &= ~(FrameFlags.Compression |
@@ -280,7 +280,7 @@
 				throw new NotImplementedException (
 					"Encryption not yet supported");
 			
-			if ((Flags & FrameFlags.Unsychronisation) != 0)
+			if ((Flags & FrameFlags.Unsynchronisation) != 0)
 				SynchData.UnsynchByteVector (field_data);
 			
 			if (front_data.Count > 0)
@@ -441,20 +441,12 @@
 			if (frameData == null)
 				throw new ArgumentNullException ("frameData");
 			
-			int data_offset = offset + (int) FrameHeader
-				.Size (version);
+			int data_offset = offset + (int) FrameHeader.Size (version);
 			int data_length = (int) Size;
-			/*int uncompressed_data_length;*/
-			
+
 			if ((Flags & (FrameFlags.Compression |
 				FrameFlags.DataLengthIndicator)) != 0) {
-				/*
-				uncompressed_data_length =
-					(int) frame_data.Mid (data_offset, 4)
-					.ToUInt () + 4;
-				*/
 				data_offset += 4;
-				data_offset -= 4;
 			}
 			
 			if ((Flags & FrameFlags.GroupingIdentity) != 0) {
@@ -472,20 +464,20 @@
 				encryption_id = frameData [data_offset++];
 				data_length--;
 			}
-			
-			if (data_length > frameData.Count - data_offset)
-				throw new CorruptFileException (
-					"Frame data incomplete.");
-			
+
+			data_length = Math.Min (data_length, frameData.Count - data_offset);
 			if (data_length < 0 )
 				throw new CorruptFileException (
 					"Frame size less than zero.");
 			
 			ByteVector data = frameData.Mid (data_offset,
 				data_length);
-			
-			if ((Flags & FrameFlags.Unsychronisation) != 0)
+
+            if ((Flags & FrameFlags.Unsynchronisation) != 0) {
+                int before_length = data.Count;
 				SynchData.ResynchByteVector (data);
+                data_length -= (data.Count - before_length);
+            }
 			
 			// FIXME: Implement encryption.
 			if ((Flags & FrameFlags.Encryption) != 0)
@@ -533,7 +525,7 @@
 		{
 			int index = 0;
 			return FrameFactory.CreateFrame (Render (4), ref index,
-				4);
+				4, false);
 		}
 		
 		object ICloneable.Clone ()
Index: src/TagLib/Mpeg/AudioFile.cs
===================================================================
--- src/TagLib/Mpeg/AudioFile.cs	(revision 121360)
+++ src/TagLib/Mpeg/AudioFile.cs	(working copy)
@@ -288,4 +288,4 @@
 		
 		#endregion
 	}
-}
\ No newline at end of file
+}
Index: src/TagLib/Mpeg/AudioHeader.cs
===================================================================
--- src/TagLib/Mpeg/AudioHeader.cs	(revision 121365)
+++ src/TagLib/Mpeg/AudioHeader.cs	(working copy)
@@ -704,6 +704,7 @@
 		                         TagLib.File file, long position,
 		                         int length)
 		{
+			long start = position;
 			if (file == null)
 				throw new ArgumentNullException ("file");
 			
Index: src/TagLib/File.cs
===================================================================
--- src/TagLib/File.cs	(revision 121360)
+++ src/TagLib/File.cs	(working copy)
@@ -604,12 +604,6 @@
 			
 			Mode = AccessMode.Read;
 			
-			if (Tell + length > Length)
-				length = (int) (Length - Tell);
-			
-			if (length <= 0)
-				return new ByteVector ();
-			
 			byte [] buffer = new byte [length];
 			int count = file_stream.Read (buffer, 0, length);
 			return new ByteVector (buffer, count);
Index: src/TagLib/NonContainer/StartTag.cs
===================================================================
--- src/TagLib/NonContainer/StartTag.cs	(revision 121360)
+++ src/TagLib/NonContainer/StartTag.cs	(working copy)
@@ -252,7 +252,7 @@
 		#region Private Methods
 		
 		/// <summary>
-		///    Reads a tag ending at a specified position and moves the
+		///    Reads a tag starting at a specified position and moves the
 		///    cursor to its start position.
 		/// </summary>
 		/// <param name="start">
@@ -283,15 +283,15 @@
 					break;
 				}
 				
-				start = end;
 			} catch (CorruptFileException) {
 			}
-			
+
+			start = end;
 			return tag;
 		}
 		
 		/// <summary>
-		///    Looks for a tag ending at a specified position and moves
+		///    Looks for a tag starting at a specified position and moves
 		///    the cursor to its start position.
 		/// </summary>
 		/// <param name="position">
Index: tests/fixtures/TagLib.Tests.FileFormats/Id3V1FormatTest.cs
===================================================================
--- tests/fixtures/TagLib.Tests.FileFormats/Id3V1FormatTest.cs	(revision 121360)
+++ tests/fixtures/TagLib.Tests.FileFormats/Id3V1FormatTest.cs	(working copy)
@@ -8,6 +8,7 @@
     public class Id3V1FormatTest : IFormatTest
     {
         private static string sample_file = "samples/sample_v1_only.mp3";
+        private static string sample_file2 = "samples/amazon.mp3";
         private static string tmp_file = "samples/tmpwrite_v1_only.mp3";
         private File file;
         
@@ -46,5 +47,15 @@
         public void TestCorruptionResistance()
         {
         }
+
+        [Test]
+        public void TestAmazonMp3()
+        {
+            file = File.Create(sample_file2);
+            Assert.AreEqual(44100, file.Properties.AudioSampleRate);
+            Assert.AreEqual(27, file.Properties.Duration.Seconds);
+            Assert.AreEqual("Lights And Sounds", file.Tag.Album);
+            Assert.AreEqual(1, file.Tag.Pictures.Length);
+        }
     }
 }
