public void Parse(ByteVector data) { if (data != null) { // 11 buffer is the minimum size for an APE item if (data.Count < 11) { TagLibDebugger.Debug("APE.Item.Parse() -- no data in item"); return; } uint value_length = data.Mid(0, 4).ToUInt(false); uint flags = data.Mid(4, 4).ToUInt(false); int pos = data.Find(new ByteVector(1), 8); key = data.Mid(8, pos - 8).ToString(StringType.UTF8); value = data.Mid(pos + 1, (int)value_length); ReadOnly = (flags & 1) == 1; Type = (ApeItemType)((flags >> 1) & 3); if (Type != ApeItemType.Binary) { text.Clear(); text = new StringCollection(ByteVectorCollection.Split(value, (byte)0), StringType.UTF8); } } else { throw new ArgumentNullException("data"); } }
protected OggPage(ByteVectorCollection packets, uint stream_serial_number, int page_number, bool first_packet_continued, bool last_packet_completed) : this(packets, stream_serial_number, page_number, first_packet_continued, last_packet_completed, false) { }
public static OggPage[] Paginate(ByteVectorCollection packets, PaginationStrategy strategy, uint streamSerialNumber, int firstPage, bool firstPacketContinued, bool lastPacketCompleted, bool containsLastPacket) { ArrayList l = new ArrayList(); int totalSize = 0; foreach (ByteVector b in packets) { totalSize += b.Count; } if (strategy == PaginationStrategy.Repaginate || totalSize + packets.Count > 255 * 256) { TagLibDebugger.Debug("Ogg.Page.Paginate() -- Sorry! Repagination is not yet implemented."); return((OggPage[])l.ToArray(typeof(OggPage))); } // TODO: Handle creation of multiple pages here with appropriate pagination. OggPage p = new OggPage(packets, streamSerialNumber, firstPage, firstPacketContinued, lastPacketCompleted, containsLastPacket); l.Add(p); return((OggPage[])l.ToArray(typeof(OggPage))); }
public static ByteVectorCollection Split(ByteVector vector, ByteVector pattern, int alignment, int maximum) { if (vector != null) { if (pattern != null) { ByteVectorCollection list = new ByteVectorCollection(); int previousOffset = 0; for (int offset = vector.Find(pattern, 0, alignment); offset != -1 && (maximum == 0 || maximum > list.Count + 1); offset = vector.Find(pattern, offset + pattern.Count, alignment)) { list.Add(vector.Mid(previousOffset, offset - previousOffset)); previousOffset = offset + pattern.Count; } if (previousOffset < vector.Count) { list.Add(vector.Mid(previousOffset, vector.Count - previousOffset)); } return(list); } else { throw new ArgumentNullException("pattern"); } } else { throw new ArgumentNullException("vector"); } }
//public Mpeg4AppleDataBox[] DataBoxes(ByteVectorCollection list) public IList <Mpeg4AppleDataBox> DataBoxes(ByteVectorCollection list) { //ArrayList l = new ArrayList(); List <Mpeg4AppleDataBox> boxes = new List <Mpeg4AppleDataBox>(); // Check each box to see if the match any of the provided types. // If a match is found, loop through the children and add any data box. foreach (Mpeg4Box box in listBox.Children) { foreach (ByteVector vector in list) { if (FixId(vector) == box.BoxType) { foreach (Mpeg4Box dataBox in box.Children) { //if (dataBox.GetType() == typeof(Mpeg4AppleDataBox)) Mpeg4AppleDataBox appleDataBox = dataBox as Mpeg4AppleDataBox; if (appleDataBox != null) { boxes.Add(appleDataBox); } } } } } // Return the results as an numbers. return(boxes); //(Mpeg4AppleDataBox[])l.ToArray(typeof(Mpeg4AppleDataBox)); }
protected OggPage(ByteVectorCollection packets, uint stream_serial_number, int page_number, bool first_packet_continued, bool last_packet_completed, bool contains_last_packet) { //file = null; fileOffset = -1; //packetOffset = 0; //dataSize = 0; header = new OggPageHeader(); firstPacketIndex = -1; this.packets = packets; ByteVector data = new ByteVector(); ArrayList packet_sizes = new ArrayList(); header.FirstPageOfStream = (page_number == 0 && !first_packet_continued); header.LastPageOfStream = contains_last_packet; header.FirstPacketContinued = first_packet_continued; header.LastPacketCompleted = last_packet_completed; header.StreamSerialNumber = stream_serial_number; header.PageSequenceNumber = page_number; // Build a page from the text of packets. foreach (ByteVector v in packets) { packet_sizes.Add(v.Count); data.Add(v); } header.SetPacketSizes((int[])packet_sizes.ToArray(typeof(int))); }
public StringCollection(ByteVectorCollection text, StringType type) { foreach (ByteVector vector in text) { Add(vector.ToString(type)); } }
private void ParseUniqueFields(ByteVector data) { ByteVectorCollection fields = ByteVectorCollection.Split(data, (byte)0); if (fields.Count != 2) { return; } owner = fields[0].ToString(StringType.Latin1); identifier = fields[1]; }
protected void ClearPageData() { streamSerialNumber = 0; pages = new List <OggPage>(); //new ArrayList (); firstPageHeader = null; lastPageHeader = null; packetToPageMap = new List <IntCollection>(); //new ArrayList(); dirtyPackets = new Dictionary <uint, ByteVector>(); //new Hashtable (); dirtyPages = new IntCollection(); currentPage = null; currentPacketPage = null; currentPackets = null; }
////////////////////////////////////////////////////////////////////////// // public methods ////////////////////////////////////////////////////////////////////////// public OggPage(OggFile file, long pageOffset) { this.file = file; this.fileOffset = pageOffset; //packetOffset = 0; //dataSize = 0; header = new OggPageHeader(file, pageOffset); firstPacketIndex = -1; packets = new ByteVectorCollection(); if (file != null) { packetOffset = fileOffset + header.Size; dataSize = header.DataSize; } }
private void ParsePrivateFields(ByteVector data) { if (data.Count < 1) { TagLibDebugger.Debug("A private frame must contain at least 1 byte."); return; } ByteVectorCollection list = ByteVectorCollection.Split(data, TextDelimiter(StringType.Latin1), 1, 2); if (list.Count == 2) { owner = list[0].ToString(StringType.Latin1); data = list[1]; } }
// Set the data with the given box type, strings, and flags. public void SetText(ByteVector type, string[] text) { // Remove empty data and return. if (text == null) { listBox.RemoveChildren(FixId(type)); return; } // Create a text... ByteVectorCollection data = new ByteVectorCollection(); // and populate it with the ByteVectorized strings. foreach (string value in text) { data.Add(ByteVector.FromString(value, StringType.UTF8)); } // Send our final byte vectors to SetData SetData(type, data, (uint)Mpeg4ContentType.ContainsText); }
private void ParseTextIdentifierFields(ByteVector data) { // read the string data type (the first byte of the field data) textEncoding = (StringType)data[0]; // split the byte numbers into chunks based on the string type (two byte delimiter // for unicode encodings) int byteAlign = textEncoding == StringType.Latin1 || textEncoding == StringType.UTF8 ? 1 : 2; ByteVectorCollection list = ByteVectorCollection.Split(data.Mid(1), TextDelimiter(textEncoding), byteAlign); fieldList.Clear(); // append those split values to the text and make sure that the new string'field // type is the same specified for this frame foreach (ByteVector vector in list) { fieldList.Add(vector.ToString(textEncoding)); } }
public void SetData(ByteVector type, ByteVectorCollection data, uint flags) { if (data != null) { if (data.Count > 0) { Mpeg4AppleDataBox[] boxes = new Mpeg4AppleDataBox[data.Count]; for (int i = 0; i < data.Count; i++) { boxes[i] = new Mpeg4AppleDataBox(data[i], flags); } SetData(type, boxes); } else { ClearData(type); } } else { ClearData(type); } }
private void ParseCommentsFields(ByteVector data) { if (data.Count < 5) { TagLibDebugger.Debug("A comment frame must contain at least 5 bytes."); return; } textEncoding = (StringType)data[0]; language = data.Mid(1, 3); int byte_align = textEncoding == StringType.Latin1 || textEncoding == StringType.UTF8 ? 1 : 2; ByteVectorCollection l = ByteVectorCollection.Split(data.Mid(4), TextDelimiter(textEncoding), byte_align, 2); if (l.Count == 2) { if (l[0].Data != null && l[0].Data.Count > 0) { description = l[0].ToString(textEncoding); } else { description = string.Empty; } if (l[1].Data != null && l[1].Data.Count > 0) { text = l[1].ToString(textEncoding); } else { text = string.Empty; } } }
public static OggPage[] Paginate(ByteVectorCollection packets, PaginationStrategy strategy, uint streamSerialNumber, int firstPage) { return(Paginate(packets, strategy, streamSerialNumber, firstPage, false)); }
public ByteVector GetPacket(uint index) { // Check to see if we're called setPacket() for this packet since the last // save: if (dirtyPackets.ContainsKey(index)) { return(dirtyPackets[index]); } // If we haven'type indexed the page where the packet we're interested in starts, // begin reading pages until we have. while (packetToPageMap.Count <= index) { if (!NextPage()) { TagLibDebugger.Debug("Ogg.File.Packet() -- Could not find the requested packet."); return(null); } } // Start reading at the first page that contains part (or all) of this packet. // If the last read stopped at the packet that we're interested in, don'type // reread its packet text. (This should make sequential packet reads fast.) int pageIndex = ((IntCollection)packetToPageMap[(int)index])[0]; if (currentPacketPage != pages[pageIndex]) { currentPacketPage = pages[pageIndex]; currentPackets = currentPacketPage.Packets; } // If the packet is completely contained in the first page that it'field in, then // just return it now. if ((currentPacketPage.ContainsPacket((int)index) & ContainsPacketSettings.CompletePacket) != 0) { return(currentPackets[(int)(index - currentPacketPage.FirstPacketIndex)]); } // If the packet is *not* completely contained in the first page that it'field a // part of then that packet trails off the end of the page. Continue appending // the pages' packet data until we hit a page that either does not end with the // packet that we're fetching or where the last packet is complete. ByteVector packet = currentPackets[currentPackets.Count - 1]; while ((currentPacketPage.ContainsPacket((int)index) & ContainsPacketSettings.EndsWithPacket) != 0 && !currentPacketPage.Header.LastPacketCompleted) { pageIndex++; if (pageIndex == pages.Count && !NextPage()) { TagLibDebugger.Debug("Ogg.File.Packet() -- Could not find the requested packet."); return(null); } currentPacketPage = (OggPage)pages[pageIndex]; currentPackets = currentPacketPage.Packets; packet.Add(currentPackets[0]); } return(packet); }
private void WritePageGroup(IntCollection page_group) { if (page_group.IsEmpty) { return; } ByteVectorCollection packets = new ByteVectorCollection(); // If the first page of the group isn'type dirty, append its partial content here. if (!dirtyPages.Contains(((OggPage)this.pages[page_group[0]]).FirstPacketIndex)) { packets.Add(((OggPage)this.pages[page_group[0]]).Packets[0]); } int previous_packet = -1; int original_size = 0; for (int i = 0; i < page_group.Count; i++) { int page = page_group[i]; uint first_packet = (uint)((OggPage)this.pages[page]).FirstPacketIndex; uint last_packet = first_packet + ((OggPage)this.pages[page]).PacketCount - 1; for (uint j = first_packet; j <= last_packet; j++) { if (i == page_group.Count - 1 && j == last_packet && !dirtyPages.Contains((int)j)) { packets.Add(((OggPage)this.pages[page]).Packets[((OggPage)this.pages[page]).Packets.Count - 1]); } else if ((int)j != previous_packet) { previous_packet = (int)j; packets.Add(GetPacket(j)); } } original_size += ((OggPage)this.pages[page]).Size; } bool continued = ((OggPage)this.pages[page_group[0]]).Header.FirstPacketContinued; bool completed = ((OggPage)this.pages[page_group[page_group.Count - 1]]).Header.LastPacketCompleted; // TODO: This pagination method isn'type accurate for what'field being done here. // This should account for real possibilities like non-aligned packets and such. OggPage[] pages = OggPage.Paginate(packets, PaginationStrategy.SinglePagePerGroup, streamSerialNumber, page_group[0], continued, completed); ByteVector data = new ByteVector(); foreach (OggPage p in pages) { data.Add(p.Render()); } // The insertion algorithms could also be improve to queue and prioritize data // on the way out. Currently it requires rewriting the file for every page // group rather than just once; however, for tagging applications there will // generally only be one page group, so it'field not worth the time for the // optimization at the moment. Insert(data, ((OggPage)this.pages[page_group[0]]).FileOffset, original_size); // Update the page index to include the pages we just created and to delete the // old pages. foreach (OggPage p in pages) { int index = p.Header.PageSequenceNumber; this.pages[index] = p; } }
public static OggPage[] Paginate(ByteVectorCollection packets, PaginationStrategy strategy, uint streamSerialNumber, int firstPage, bool firstPacketContinued) { return(Paginate(packets, strategy, streamSerialNumber, firstPage, firstPacketContinued, true)); }
protected OggPage(ByteVectorCollection packets, uint stream_serial_number, int page_number) : this(packets, stream_serial_number, page_number, false) { }
public StringCollection(ByteVectorCollection text) : this(text, StringType.UTF8) { }