コード例 #1
0
    def _inject(self, fileobj, padding_func):
        """Write tag data into the Vorbis comment packet/page."""

        # Find the old pages in the file; we'll need to remove them,
        # plus grab any stray setup packet data out of them.
        fileobj.seek(0)
        page = OggPage(fileobj)
        while not page.packets[0].startswith(b"\x03vorbis"):
            page = OggPage(fileobj)

        old_pages = [page]
        while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
            page = OggPage(fileobj)
            if page.serial == old_pages[0].serial:
                old_pages.append(page)

        packets = OggPage.to_packets(old_pages, strict=False)

        content_size = get_size(fileobj) - len(packets[0])  # approx
        vcomment_data = b"\x03vorbis" + self.write()
        padding_left = len(packets[0]) - len(vcomment_data)

        info = PaddingInfo(padding_left, content_size)
        new_padding = info._get_padding(padding_func)

        # Set the new comment packet.
        packets[0] = vcomment_data + b"\x00" * new_padding

        new_pages = OggPage._from_packets_try_preserve(packets, old_pages)
        OggPage.replace(fileobj, old_pages, new_pages)
コード例 #2
0
ファイル: test_ogg.py プロジェクト: Sophist-UK/mutagen
 def test_to_packets(self):
     self.failUnlessEqual(
         [b"foo", b"bar", b"baz"], OggPage.to_packets(self.pages))
     self.pages[0].complete = False
     self.pages[1].continued = True
     self.failUnlessEqual(
         [b"foobar", b"baz"], OggPage.to_packets(self.pages))
コード例 #3
0
ファイル: test_ogg.py プロジェクト: svetlio2/hackbg
    def test_crc_py25(self):
        # Make sure page.write can handle both signed/unsigned int
        # return values of crc32.
        # http://code.google.com/p/mutagen/issues/detail?id=63
        # http://docs.python.org/library/zlib.html#zlib.crc32

        import zlib
        old_crc = zlib.crc32

        def zlib_uint(*args):
            return (old_crc(*args) & 0xffffffff)

        def zlib_int(*args):
            return cdata.int_be(cdata.to_uint_be(old_crc(*args) & 0xffffffff))

        try:
            page = OggPage()
            page.packets = [b"abc"]
            zlib.crc32 = zlib_uint
            uint_data = page.write()
            zlib.crc32 = zlib_int
            int_data = page.write()
        finally:
            zlib.crc32 = old_crc

        self.failUnlessEqual(uint_data, int_data)
コード例 #4
0
ファイル: oggspeex.py プロジェクト: Gimpson/pytivo
    def _inject(self, fileobj):
        """Write tag data into the Speex comment packet/page."""

        fileobj.seek(0)

        # Find the first header page, with the stream info.
        # Use it to get the serial number.
        page = OggPage(fileobj)
        while not page.packets[0].startswith("Speex   "):
            page = OggPage(fileobj)

        # Look for the next page with that serial number, it'll start
        # the comment packet.
        serial = page.serial
        page = OggPage(fileobj)
        while page.serial != serial:
            page = OggPage(fileobj)

        # Then find all the pages with the comment packet.
        old_pages = [page]
        while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
            page = OggPage(fileobj)
            if page.serial == old_pages[0].serial:
                old_pages.append(page)

        packets = OggPage.to_packets(old_pages, strict=False)

        # Set the new comment packet.
        packets[0] = self.write(framing=False)

        new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
        OggPage.replace(fileobj, old_pages, new_pages)
コード例 #5
0
    def _inject(self, fileobj, padding_func):
        """Write tag data into the Theora comment packet/page."""

        fileobj.seek(0)
        page = OggPage(fileobj)
        while not page.packets[0].startswith(b"\x81theora"):
            page = OggPage(fileobj)

        old_pages = [page]
        while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
            page = OggPage(fileobj)
            if page.serial == old_pages[0].serial:
                old_pages.append(page)

        packets = OggPage.to_packets(old_pages, strict=False)

        content_size = get_size(fileobj) - len(packets[0])  # approx
        vcomment_data = b"\x81theora" + self.write(framing=False)
        padding_left = len(packets[0]) - len(vcomment_data)

        info = PaddingInfo(padding_left, content_size)
        new_padding = info._get_padding(padding_func)

        packets[0] = vcomment_data + b"\x00" * new_padding

        new_pages = OggPage._from_packets_try_preserve(packets, old_pages)
        OggPage.replace(fileobj, old_pages, new_pages)
コード例 #6
0
ファイル: oggflac.py プロジェクト: fourth-4/mutagen
    def _inject(self, fileobj):
        """Write tag data into the FLAC Vorbis comment packet/page."""

        # Ogg FLAC has no convenient data marker like Vorbis, but the
        # second packet - and second page - must be the comment data.
        fileobj.seek(0)
        page = OggPage(fileobj)
        while not page.packets[0].startswith(b"\x7FFLAC"):
            page = OggPage(fileobj)

        first_page = page
        while not (page.sequence == 1 and page.serial == first_page.serial):
            page = OggPage(fileobj)

        old_pages = [page]
        while not (old_pages[-1].complete or len(old_pages[-1].packets) > 1):
            page = OggPage(fileobj)
            if page.serial == first_page.serial:
                old_pages.append(page)

        packets = OggPage.to_packets(old_pages, strict=False)

        # Set the new comment block.
        data = self.write()
        data = bytes((packets[0][0],)) + struct.pack(">I", len(data))[-3:] + data
        packets[0] = data

        new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
        OggPage.replace(fileobj, old_pages, new_pages)
コード例 #7
0
 def test_theora_bad_version(self):
     page = OggPage(open(self.filename, "rb"))
     packet = page.packets[0]
     packet = packet[:7] + b"\x03\x00" + packet[9:]
     page.packets = [packet]
     fileobj = cBytesIO(page.write())
     self.failUnlessRaises(IOError, OggTheoraInfo, fileobj)
コード例 #8
0
ファイル: test_ogg.py プロジェクト: quodlibet/mutagen
 def test_find_last_single_muxed(self):
     page1 = OggPage()
     page1.last = True
     page2 = OggPage()
     page2.serial = page1.serial + 1
     pages = [page1, page2]
     data = BytesIO(b"".join([page.write() for page in pages]))
     assert OggPage.find_last(data, page2.serial).serial == page2.serial
コード例 #9
0
ファイル: test_ogg.py プロジェクト: fourth-4/mutagen
    def test_too_many_packets(self):
        packets = [b"1"] * 3000
        pages = OggPage.from_packets(packets)

        for p in pages:
            OggPage.write(p)

        self.failUnless(len(pages) > 3000//255)
コード例 #10
0
ファイル: test_oggvorbis.py プロジェクト: akerbis/mutagen
 def test_underestimated_bitrate(self):
     page = OggPage(open(self.filename, "rb"))
     packet = page.packets[0]
     packet = (packet[:16] + b"\x00\x00\x01\x00" + b"\x01\x00\x00\x00" +
               b"\x00\x00\x01\x00" + packet[28:])
     page.packets[0] = packet
     info = OggVorbisInfo(cBytesIO(page.write()))
     self.failUnlessEqual(info.bitrate, 65536)
コード例 #11
0
ファイル: test_oggvorbis.py プロジェクト: akerbis/mutagen
 def test_negative_bitrate(self):
     page = OggPage(open(self.filename, "rb"))
     packet = page.packets[0]
     packet = (packet[:16] + b"\xff\xff\xff\xff" + b"\xff\xff\xff\xff" +
               b"\xff\xff\xff\xff" + packet[28:])
     page.packets[0] = packet
     info = OggVorbisInfo(cBytesIO(page.write()))
     self.failUnlessEqual(info.bitrate, 0)
コード例 #12
0
 def test_avg_bitrate(self):
     page = OggPage(open(self.filename, "rb"))
     packet = page.packets[0]
     packet = (packet[:16] + "\x00\x00\x01\x00" + "\x00\x00\x00\x00" +
               "\x00\x00\x00\x00" + packet[28:])
     page.packets[0] = packet
     info = OggVorbisInfo(StringIO(page.write()))
     self.failUnlessEqual(info.bitrate, 32768)
コード例 #13
0
ファイル: test_oggvorbis.py プロジェクト: Knio/tag2itunes
 def test_overestimated_bitrate(self):
     page = OggPage(file(self.filename, "rb"))
     packet = page.packets[0]
     packet = (packet[:16] + "\x00\x00\x01\x00" + "\x00\x00\x00\x01" +
               "\x00\x00\x00\x00" + packet[28:])
     page.packets[0] = packet
     info = OggVorbisInfo(StringIO(page.write()))
     self.failUnlessEqual(info.bitrate, 65536)
コード例 #14
0
ファイル: oggopus.py プロジェクト: Begall/headphones
    def _inject(self, fileobj):
        fileobj.seek(0)
        info = OggOpusInfo(fileobj)
        old_pages = self.__get_comment_pages(fileobj, info)

        packets = OggPage.to_packets(old_pages)
        packets[0] = "OpusTags" + self.write(framing=False)
        new_pages = OggPage.from_packets(packets, old_pages[0].sequence)
        OggPage.replace(fileobj, old_pages, new_pages)
コード例 #15
0
ファイル: test_ogg.py プロジェクト: quodlibet/mutagen
 def test_renumber_reread(self):
     try:
         filename = get_temp_copy(
             os.path.join(DATA_DIR, "multipagecomment.ogg"))
         with open(filename, "rb+") as fileobj:
             OggPage.renumber(fileobj, 1002429366, 20)
         with open(filename, "rb+") as fileobj:
             OggPage.renumber(fileobj, 1002429366, 0)
     finally:
         os.unlink(filename)
コード例 #16
0
ファイル: test_ogg.py プロジェクト: hanvo/MusicCloud
 def test_random_data_roundtrip(self):
     try:
         random_file = open("/dev/urandom", "rb")
     except (IOError, OSError):
         print "WARNING: Random data round trip test disabled."
         return
     for i in range(10):
         num_packets = random.randrange(2, 100)
         lengths = [random.randrange(10, 10000) for i in range(num_packets)]
         packets = map(random_file.read, lengths)
         self.failUnlessEqual(packets, OggPage.to_packets(OggPage.from_packets(packets)))
コード例 #17
0
    def test_unsupported_version(self):
        page = OggPage(open(self.filename, "rb"))
        data = list(page.packets[0])

        data[8] = "\x03"
        page.packets[0] = "".join(data)
        OggOpusInfo(StringIO(page.write()))

        data[8] = "\x10"
        page.packets[0] = "".join(data)
        self.failUnlessRaises(IOError, OggOpusInfo, StringIO(page.write()))
コード例 #18
0
ファイル: test_oggopus.py プロジェクト: svetlio2/hackbg
    def test_unsupported_version(self):
        page = OggPage(open(self.filename, "rb"))
        data = bytearray(page.packets[0])

        data[8] = 0x03
        page.packets[0] = bytes(data)
        OggOpusInfo(BytesIO(page.write()))

        data[8] = 0x10
        page.packets[0] = bytes(data)
        self.failUnlessRaises(IOError, OggOpusInfo, BytesIO(page.write()))
コード例 #19
0
ファイル: moggsplit.py プロジェクト: YipYup/headphones
def main(argv):
    from mutagen.ogg import OggPage
    parser = OptionParser(
        usage="%prog [options] filename.ogg ...",
        description="Split Ogg logical streams using Mutagen.",
        version="Mutagen %s" % ".".join(map(str, mutagen.version))
    )

    parser.add_option(
        "--extension", dest="extension", default="ogg", metavar='ext',
        help="use this extension (default 'ogg')")
    parser.add_option(
        "--pattern", dest="pattern", default="%(base)s-%(stream)d.%(ext)s",
        metavar='pattern', help="name files using this pattern")
    parser.add_option(
        "--m3u", dest="m3u", action="store_true", default=False,
        help="generate an m3u (playlist) file")

    (options, args) = parser.parse_args(argv[1:])
    if not args:
        raise SystemExit(parser.print_help() or 1)

    format = {'ext': options.extension}
    for filename in args:
        with _sig.block():
            fileobjs = {}
            format["base"] = os.path.splitext(os.path.basename(filename))[0]
            fileobj = open(filename, "rb")
            if options.m3u:
                m3u = open(format["base"] + ".m3u", "w")
                fileobjs["m3u"] = m3u
            else:
                m3u = None
            while True:
                try:
                    page = OggPage(fileobj)
                except EOFError:
                    break
                else:
                    format["stream"] = page.serial
                    if page.serial not in fileobjs:
                        new_filename = options.pattern % format
                        new_fileobj = open(new_filename, "wb")
                        fileobjs[page.serial] = new_fileobj
                        if m3u:
                            m3u.write(new_filename + "\r\n")
                    fileobjs[page.serial].write(page.write())
            for f in fileobjs.values():
                f.close()
コード例 #20
0
ファイル: test_ogg.py プロジェクト: Sophist-UK/mutagen
 def test_renumber_reread(self):
     try:
         fd, filename = mkstemp(suffix=".ogg")
         os.close(fd)
         shutil.copy(os.path.join("tests", "data", "multipagecomment.ogg"),
                     filename)
         fileobj = open(filename, "rb+")
         OggPage.renumber(fileobj, 1002429366, 20)
         fileobj.close()
         fileobj = open(filename, "rb+")
         OggPage.renumber(fileobj, 1002429366, 0)
         fileobj.close()
     finally:
         try: os.unlink(filename)
         except OSError: pass
コード例 #21
0
ファイル: test_ogg.py プロジェクト: Sophist-UK/mutagen
 def test_renumber_muxed(self):
     pages = [OggPage() for i in range(10)]
     for seq, page in enumerate(pages[0:1] + pages[2:]):
         page.serial = 0
         page.sequence = seq
     pages[1].serial = 2
     pages[1].sequence = 100
     data = BytesIO(bytearray().join([page.write() for page in pages]))
     OggPage.renumber(data, 0, 20)
     data.seek(0)
     pages = [OggPage(data) for i in range(10)]
     self.failUnlessEqual(pages[1].serial, 2)
     self.failUnlessEqual(pages[1].sequence, 100)
     pages.pop(1)
     self.failUnlessEqual([page.sequence for page in pages], list(range(20, 29)))
コード例 #22
0
ファイル: icy_write_vorb.py プロジェクト: XiaonuoGantan/ireul
def yield_pages(track_derived):
    fh = track_derived.open()
    yield OggPage(fh)
    tmp = OggPage(fh)
    # replace outgoing tag
    tmp.packets[0] = create_metadata_packet([
        ('title', track_derived.original.title),
        ('artist', track_derived.original.artist),
        ('x-ireul-id', unicode(track_derived.id))])
    yield tmp
    try:
        while True:
            yield OggPage(fh)
    except EOFError:
        pass
コード例 #23
0
ファイル: test_ogg.py プロジェクト: quodlibet/mutagen
 def test_find_last_last_empty(self):
     # https://github.com/quodlibet/mutagen/issues/308
     pages = [OggPage() for i in xrange(10)]
     for i, page in enumerate(pages):
         page.sequence = i
         page.position = i
     pages[-1].last = True
     pages[-1].position = -1
     data = BytesIO(b"".join([page.write() for page in pages]))
     page = OggPage.find_last(data, pages[-1].serial, finishing=True)
     assert page is not None
     assert page.position == 8
     page = OggPage.find_last(data, pages[-1].serial, finishing=False)
     assert page is not None
     assert page.position == -1
コード例 #24
0
ファイル: test_ogg.py プロジェクト: douglaskastle/mutagen
 def test_find_last(self):
     pages = [OggPage() for i in xrange(10)]
     for i, page in enumerate(pages):
         page.sequence = i
     data = BytesIO(b"".join([page.write() for page in pages]))
     self.failUnlessEqual(
         OggPage.find_last(data, pages[0].serial), pages[-1])
コード例 #25
0
ファイル: test_ogg.py プロジェクト: hanvo/MusicCloud
    def test_renumber(self):
        self.failUnlessEqual([page.sequence for page in self.pages], [0, 1, 2])
        fileobj = StringIO()
        for page in self.pages:
            fileobj.write(page.write())
        fileobj.seek(0)
        OggPage.renumber(fileobj, 1, 10)
        fileobj.seek(0)
        pages = [OggPage(fileobj) for i in range(3)]
        self.failUnlessEqual([page.sequence for page in pages], [10, 11, 12])

        fileobj.seek(0)
        OggPage.renumber(fileobj, 1, 20)
        fileobj.seek(0)
        pages = [OggPage(fileobj) for i in range(3)]
        self.failUnlessEqual([page.sequence for page in pages], [20, 21, 22])
コード例 #26
0
ファイル: test_ogg.py プロジェクト: Sophist-UK/mutagen
 def test_from_packets_position(self):
     packets = [b"1" * 100000]
     pages = OggPage.from_packets(packets)
     self.failUnless(len(pages) > 1)
     for page in pages[:-1]:
         self.failUnlessEqual(-1, page.position)
     self.failUnlessEqual(0, pages[-1].position)
コード例 #27
0
ファイル: oggflac.py プロジェクト: 2216288075/meiduo_project
 def _post_tags(self, fileobj):
     if self.length:
         return
     page = OggPage.find_last(fileobj, self.serial, finishing=True)
     if page is None:
         raise OggFLACHeaderError
     self.length = page.position / float(self.sample_rate)
コード例 #28
0
ファイル: test_ogg.py プロジェクト: Sophist-UK/mutagen
 def test_find_last_really_last(self):
     pages = [OggPage() for i in range(10)]
     pages[-1].last = True
     for i, page in enumerate(pages): page.sequence = i
     data = BytesIO(bytearray().join([page.write() for page in pages]))
     self.failUnlessEqual(
         OggPage.find_last(data, pages[0].serial), pages[-1])
コード例 #29
0
ファイル: oggvorbis.py プロジェクト: YipYup/headphones
    def _post_tags(self, fileobj):
        """Raises ogg.error"""

        page = OggPage.find_last(fileobj, self.serial)
        if page is None:
            raise OggVorbisHeaderError
        self.length = page.position / float(self.sample_rate)
コード例 #30
0
ファイル: test_ogg.py プロジェクト: hanvo/MusicCloud
 def test_page_max_size(self):
     page = OggPage()
     page.packets = ["1" * 255 * 255]
     page.complete = False
     page2 = OggPage()
     page2.packets = [""]
     page2.sequence = 1
     page2.continued = True
     self.failUnlessEqual(["1" * 255 * 255], OggPage.to_packets([page, page2]))
コード例 #31
0
 def _post_tags(self, fileobj):
     page = OggPage.find_last(fileobj, self.serial)
     self.length = (page.position - self.__pre_skip) / float(48000)
コード例 #32
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_not_equal(self):
     self.failIfEqual(OggPage(), 12)
コード例 #33
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_find_last_no_serial(self):
     pages = [OggPage() for i in xrange(10)]
     for i, page in enumerate(pages):
         page.sequence = i
     data = BytesIO(b"".join([page.write() for page in pages]))
     self.failUnless(OggPage.find_last(data, pages[0].serial + 1) is None)
コード例 #34
0
ファイル: oggflac.py プロジェクト: libanp/plugin.video.emby
 def _post_tags(self, fileobj):
     if self.length:
         return
     page = OggPage.find_last(fileobj, self.serial)
     self.length = page.position / float(self.sample_rate)
コード例 #35
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_at_least_one_audio_page(self):
     page = OggPage(self.fileobj)
     while not page.last:
         page = OggPage(self.fileobj)
     self.failUnless(page.last)
コード例 #36
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_one_packet_per_wiggle(self):
     packets = [b"1" * 511, b"2" * 511, b"3" * 511]
     pages = OggPage.from_packets(
         packets, default_size=1000, wiggle_room=1000000)
     self.failUnlessEqual(len(pages), 2)
     self.failUnlessEqual(OggPage.to_packets(pages), packets)
コード例 #37
0
 def test_invalid_not_first(self):
     with open(self.filename, "rb") as h:
         page = OggPage(h)
     page.first = False
     self.failUnlessRaises(error, OggSpeexInfo, BytesIO(page.write()))
コード例 #38
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
class TOggPage(TestCase):
    def setUp(self):
        self.fileobj = open(os.path.join(DATA_DIR, "empty.ogg"), "rb")
        self.page = OggPage(self.fileobj)

        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].packets = [b"foo"]
        pages[1].packets = [b"bar"]
        pages[2].packets = [b"baz"]
        for i in range(len(pages)):
            pages[i].sequence = i
        for page in pages:
            page.serial = 1
        self.pages = pages

    def test_to_packets_empty_page(self):
        pages = [OggPage(), OggPage()]
        for i in range(len(pages)):
            pages[i].sequence = i
        assert OggPage.to_packets(pages, True) == []
        assert OggPage.to_packets(pages, False) == []

        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].packets = [b"foo"]
        pages[0].complete = False
        pages[1].continued = True
        pages[1].complete = False
        pages[2].packets = [b"bar"]
        pages[2].continued = True
        for i in range(len(pages)):
            pages[i].sequence = i
        assert OggPage.to_packets(pages, True) == [b'foobar']

    def test_flags(self):
        self.failUnless(self.page.first)
        self.failIf(self.page.continued)
        self.failIf(self.page.last)
        self.failUnless(self.page.complete)

        for first in [True, False]:
            self.page.first = first
            for last in [True, False]:
                self.page.last = last
                for continued in [True, False]:
                    self.page.continued = continued
                    self.failUnlessEqual(self.page.first, first)
                    self.failUnlessEqual(self.page.last, last)
                    self.failUnlessEqual(self.page.continued, continued)

    def test_flags_next_page(self):
        page = OggPage(self.fileobj)
        self.failIf(page.first)
        self.failIf(page.continued)
        self.failIf(page.last)

    def test_length(self):
        # Always true for Ogg Vorbis files
        self.failUnlessEqual(self.page.size, 58)
        self.failUnlessEqual(len(self.page.write()), 58)

    def test_first_metadata_page_is_separate(self):
        self.failIf(OggPage(self.fileobj).continued)

    def test_single_page_roundtrip(self):
        self.failUnlessEqual(self.page, OggPage(BytesIO(self.page.write())))

    def test_at_least_one_audio_page(self):
        page = OggPage(self.fileobj)
        while not page.last:
            page = OggPage(self.fileobj)
        self.failUnless(page.last)

    def test_crappy_fragmentation(self):
        packets = [b"1" * 511, b"2" * 511, b"3" * 511]
        pages = OggPage.from_packets(packets, default_size=510, wiggle_room=0)
        self.failUnless(len(pages) > 3)
        self.failUnlessEqual(OggPage.to_packets(pages), packets)

    def test_wiggle_room(self):
        packets = [b"1" * 511, b"2" * 511, b"3" * 511]
        pages = OggPage.from_packets(packets,
                                     default_size=510,
                                     wiggle_room=100)
        self.failUnlessEqual(len(pages), 3)
        self.failUnlessEqual(OggPage.to_packets(pages), packets)

    def test_one_packet_per_wiggle(self):
        packets = [b"1" * 511, b"2" * 511, b"3" * 511]
        pages = OggPage.from_packets(packets,
                                     default_size=1000,
                                     wiggle_room=1000000)
        self.failUnlessEqual(len(pages), 2)
        self.failUnlessEqual(OggPage.to_packets(pages), packets)

    def test_replace(self):
        # create interleaved pages
        fileobj = BytesIO()
        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].serial = 42
        pages[0].sequence = 0
        pages[0].packets = [b"foo"]
        pages[1].serial = 24
        pages[1].sequence = 0
        pages[1].packets = [b"bar"]
        pages[2].serial = 42
        pages[2].sequence = 1
        pages[2].packets = [b"baz"]
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]

        old_pages = [pages_from_file[0], pages_from_file[2]]
        packets = OggPage.to_packets(old_pages, strict=True)
        self.assertEqual(packets, [b"foo", b"baz"])
        new_packets = [b"1111", b"2222"]
        new_pages = OggPage.from_packets(new_packets,
                                         sequence=old_pages[0].sequence)
        self.assertEqual(len(new_pages), 1)
        OggPage.replace(fileobj, old_pages, new_pages)

        fileobj.seek(0, 0)
        first = OggPage(fileobj)
        self.assertEqual(first.serial, 42)
        self.assertEqual(OggPage.to_packets([first], strict=True),
                         [b"1111", b"2222"])
        second = OggPage(fileobj)
        self.assertEqual(second.serial, 24)
        self.assertEqual(OggPage.to_packets([second], strict=True), [b"bar"])

    def test_replace_fast_path(self):
        # create interleaved pages
        fileobj = BytesIO()
        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].serial = 42
        pages[0].sequence = 0
        pages[0].packets = [b"foo"]
        pages[1].serial = 24
        pages[1].sequence = 0
        pages[1].packets = [b"bar"]
        pages[2].serial = 42
        pages[2].sequence = 1
        pages[2].packets = [b"baz"]
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]

        old_pages = [pages_from_file[0], pages_from_file[2]]
        packets = OggPage.to_packets(old_pages, strict=True)
        self.assertEqual(packets, [b"foo", b"baz"])
        new_packets = [b"111", b"222"]
        new_pages = OggPage._from_packets_try_preserve(new_packets, old_pages)
        self.assertEqual(len(new_pages), 2)

        # remove insert_bytes, so we can be sure the fast path was taken
        old_insert_bytes = _util.insert_bytes
        _util.insert_bytes = None
        try:
            OggPage.replace(fileobj, old_pages, new_pages)
        finally:
            _util.insert_bytes = old_insert_bytes

        # validate that the new data was written and the other pages
        # are untouched
        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]
        packets = OggPage.to_packets([pages_from_file[0], pages_from_file[2]],
                                     strict=True)
        self.assertEqual(packets, [b"111", b"222"])
        packets = OggPage.to_packets([pages_from_file[1]], strict=True)
        self.assertEqual(packets, [b"bar"])

    def test_replace_continued(self):
        # take a partial packet and replace it with a new page
        # replace() should make it spanning again
        fileobj = BytesIO()
        pages = [OggPage(), OggPage()]
        pages[0].serial = 1
        pages[0].sequence = 0
        pages[0].complete = False
        pages[0].packets = [b"foo"]
        pages[1].serial = 1
        pages[1].sequence = 1
        pages[1].continued = True
        pages[1].packets = [b"bar"]
        fileobj = BytesIO()
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [OggPage(fileobj), OggPage(fileobj)]
        self.assertEqual(OggPage.to_packets(pages_from_file), [b"foobar"])
        packets_part = OggPage.to_packets([pages_from_file[0]])
        self.assertEqual(packets_part, [b"foo"])
        new_pages = OggPage.from_packets([b"quuux"])
        OggPage.replace(fileobj, [pages_from_file[0]], new_pages)

        fileobj.seek(0, 0)
        written = OggPage.to_packets([OggPage(fileobj), OggPage(fileobj)])
        self.assertEquals(written, [b"quuuxbar"])

    def test_renumber(self):
        self.failUnlessEqual([page.sequence for page in self.pages], [0, 1, 2])
        fileobj = BytesIO()
        for page in self.pages:
            fileobj.write(page.write())
        fileobj.seek(0)
        OggPage.renumber(fileobj, 1, 10)
        fileobj.seek(0)
        pages = [OggPage(fileobj) for i in range(3)]
        self.failUnlessEqual([page.sequence for page in pages], [10, 11, 12])

        fileobj.seek(0)
        OggPage.renumber(fileobj, 1, 20)
        fileobj.seek(0)
        pages = [OggPage(fileobj) for i in range(3)]
        self.failUnlessEqual([page.sequence for page in pages], [20, 21, 22])

    def test_renumber_extradata(self):
        fileobj = BytesIO()
        for page in self.pages:
            fileobj.write(page.write())
        fileobj.write(b"left over data")
        fileobj.seek(0)
        # Trying to rewrite should raise an error...
        self.failUnlessRaises(Exception, OggPage.renumber, fileobj, 1, 10)
        fileobj.seek(0)
        # But the already written data should remain valid,
        pages = [OggPage(fileobj) for i in range(3)]
        self.failUnlessEqual([page.sequence for page in pages], [10, 11, 12])
        # And the garbage that caused the error should be okay too.
        self.failUnlessEqual(fileobj.read(), b"left over data")

    def test_renumber_reread(self):
        try:
            filename = get_temp_copy(
                os.path.join(DATA_DIR, "multipagecomment.ogg"))
            with open(filename, "rb+") as fileobj:
                OggPage.renumber(fileobj, 1002429366, 20)
            with open(filename, "rb+") as fileobj:
                OggPage.renumber(fileobj, 1002429366, 0)
        finally:
            os.unlink(filename)

    def test_renumber_muxed(self):
        pages = [OggPage() for i in range(10)]
        for seq, page in enumerate(pages[0:1] + pages[2:]):
            page.serial = 0
            page.sequence = seq
        pages[1].serial = 2
        pages[1].sequence = 100
        data = BytesIO(b"".join([page.write() for page in pages]))
        OggPage.renumber(data, 0, 20)
        data.seek(0)
        pages = [OggPage(data) for i in range(10)]
        self.failUnlessEqual(pages[1].serial, 2)
        self.failUnlessEqual(pages[1].sequence, 100)
        pages.pop(1)
        self.failUnlessEqual([page.sequence for page in pages],
                             list(range(20, 29)))

    def test_to_packets(self):
        self.failUnlessEqual([b"foo", b"bar", b"baz"],
                             OggPage.to_packets(self.pages))
        self.pages[0].complete = False
        self.pages[1].continued = True
        self.failUnlessEqual([b"foobar", b"baz"],
                             OggPage.to_packets(self.pages))

    def test_to_packets_mixed_stream(self):
        self.pages[0].serial = 3
        self.failUnlessRaises(ValueError, OggPage.to_packets, self.pages)

    def test_to_packets_missing_sequence(self):
        self.pages[0].sequence = 3
        self.failUnlessRaises(ValueError, OggPage.to_packets, self.pages)

    def test_to_packets_continued(self):
        self.pages[0].continued = True
        self.failUnlessEqual(OggPage.to_packets(self.pages),
                             [b"foo", b"bar", b"baz"])

    def test_to_packets_continued_strict(self):
        self.pages[0].continued = True
        self.failUnlessRaises(ValueError,
                              OggPage.to_packets,
                              self.pages,
                              strict=True)

    def test_to_packets_strict(self):
        for page in self.pages:
            page.complete = False
        self.failUnlessRaises(ValueError,
                              OggPage.to_packets,
                              self.pages,
                              strict=True)

    def test_from_packets_short_enough(self):
        packets = [b"1" * 200, b"2" * 200, b"3" * 200]
        pages = OggPage.from_packets(packets)
        self.failUnlessEqual(OggPage.to_packets(pages), packets)

    def test_from_packets_position(self):
        packets = [b"1" * 100000]
        pages = OggPage.from_packets(packets)
        self.failUnless(len(pages) > 1)
        for page in pages[:-1]:
            self.failUnlessEqual(-1, page.position)
        self.failUnlessEqual(0, pages[-1].position)

    def test_from_packets_long(self):
        packets = [b"1" * 100000, b"2" * 100000, b"3" * 100000]
        pages = OggPage.from_packets(packets)
        self.failIf(pages[0].complete)
        self.failUnless(pages[1].continued)
        self.failUnlessEqual(OggPage.to_packets(pages), packets)

    def test__from_packets_try_preserve(self):
        # if the packet layout matches, just create pages with
        # the same layout and copy things over
        packets = [b"1" * 100000, b"2" * 100000, b"3" * 100000]
        pages = OggPage.from_packets(packets, sequence=42, default_size=977)
        new_pages = OggPage._from_packets_try_preserve(packets, pages)
        self.assertEqual(pages, new_pages)

        # zero case
        new_pages = OggPage._from_packets_try_preserve([], pages)
        self.assertEqual(new_pages, [])

        # if the layout doesn't match we should fall back to creating new
        # pages starting with the sequence of the first given page
        other_packets = list(packets)
        other_packets[1] += b"\xff"
        other_pages = OggPage.from_packets(other_packets, 42)
        new_pages = OggPage._from_packets_try_preserve(other_packets, pages)
        self.assertEqual(new_pages, other_pages)

    def test_random_data_roundtrip(self):
        try:
            random_file = open("/dev/urandom", "rb")
        except (IOError, OSError):
            print("WARNING: Random data round trip test disabled.")
            return
        try:
            for i in range(10):
                num_packets = random.randrange(2, 100)
                lengths = [
                    random.randrange(10, 10000) for i in range(num_packets)
                ]
                packets = list(map(random_file.read, lengths))
                self.failUnlessEqual(
                    packets, OggPage.to_packets(OggPage.from_packets(packets)))
        finally:
            random_file.close()

    def test_packet_exactly_255(self):
        page = OggPage()
        page.packets = [b"1" * 255]
        page.complete = False
        page2 = OggPage()
        page2.packets = [b""]
        page2.sequence = 1
        page2.continued = True
        self.failUnlessEqual([b"1" * 255], OggPage.to_packets([page, page2]))

    def test_page_max_size_alone_too_big(self):
        page = OggPage()
        page.packets = [b"1" * 255 * 255]
        page.complete = True
        self.failUnlessRaises(ValueError, page.write)

    def test_page_max_size(self):
        page = OggPage()
        page.packets = [b"1" * 255 * 255]
        page.complete = False
        page2 = OggPage()
        page2.packets = [b""]
        page2.sequence = 1
        page2.continued = True
        self.failUnlessEqual([b"1" * 255 * 255],
                             OggPage.to_packets([page, page2]))

    def test_complete_zero_length(self):
        packets = [b""] * 20
        page = OggPage.from_packets(packets)[0]
        new_page = OggPage(BytesIO(page.write()))
        self.failUnlessEqual(new_page, page)
        self.failUnlessEqual(OggPage.to_packets([new_page]), packets)

    def test_too_many_packets(self):
        packets = [b"1"] * 3000
        pages = OggPage.from_packets(packets)
        map(OggPage.write, pages)
        self.failUnless(len(pages) > 3000 // 255)

    def test_read_max_size(self):
        page = OggPage()
        page.packets = [b"1" * 255 * 255]
        page.complete = False
        page2 = OggPage()
        page2.packets = [b"", b"foo"]
        page2.sequence = 1
        page2.continued = True
        data = page.write() + page2.write()
        fileobj = BytesIO(data)
        self.failUnlessEqual(OggPage(fileobj), page)
        self.failUnlessEqual(OggPage(fileobj), page2)
        self.failUnlessRaises(EOFError, OggPage, fileobj)

    def test_invalid_version(self):
        page = OggPage()
        OggPage(BytesIO(page.write()))
        page.version = 1
        self.failUnlessRaises(OggError, OggPage, BytesIO(page.write()))

    def test_not_enough_lacing(self):
        data = OggPage().write()[:-1] + b"\x10"
        self.failUnlessRaises(OggError, OggPage, BytesIO(data))

    def test_not_enough_data(self):
        data = OggPage().write()[:-1] + b"\x01\x10"
        self.failUnlessRaises(OggError, OggPage, BytesIO(data))

    def test_not_equal(self):
        self.failIfEqual(OggPage(), 12)

    def test_find_last(self):
        pages = [OggPage() for i in range(10)]
        for i, page in enumerate(pages):
            page.sequence = i
        data = BytesIO(b"".join([page.write() for page in pages]))
        self.failUnlessEqual(OggPage.find_last(data, pages[0].serial),
                             pages[-1])

    def test_find_last_none_finishing(self):
        page = OggPage()
        page.position = -1
        data = BytesIO(page.write())
        assert OggPage.find_last(data, page.serial, finishing=True) is None

    def test_find_last_none_finishing_mux(self):
        page1 = OggPage()
        page1.last = True
        page1.position = -1
        page2 = OggPage()
        page2.serial = page1.serial + 1
        pages = [page1, page2]
        data = BytesIO(b"".join([page.write() for page in pages]))

        assert OggPage.find_last(data, page1.serial, finishing=True) is None
        assert OggPage.find_last(data, page2.serial, finishing=True) == page2

    def test_find_last_last_empty(self):
        # https://github.com/quodlibet/mutagen/issues/308
        pages = [OggPage() for i in range(10)]
        for i, page in enumerate(pages):
            page.sequence = i
            page.position = i
        pages[-1].last = True
        pages[-1].position = -1
        data = BytesIO(b"".join([page.write() for page in pages]))
        page = OggPage.find_last(data, pages[-1].serial, finishing=True)
        assert page is not None
        assert page.position == 8
        page = OggPage.find_last(data, pages[-1].serial, finishing=False)
        assert page is not None
        assert page.position == -1

    def test_find_last_single_muxed(self):
        page1 = OggPage()
        page1.last = True
        page2 = OggPage()
        page2.serial = page1.serial + 1
        pages = [page1, page2]
        data = BytesIO(b"".join([page.write() for page in pages]))
        assert OggPage.find_last(data, page2.serial).serial == page2.serial

    def test_find_last_really_last(self):
        pages = [OggPage() for i in range(10)]
        pages[-1].last = True
        for i, page in enumerate(pages):
            page.sequence = i
        data = BytesIO(b"".join([page.write() for page in pages]))
        self.failUnlessEqual(OggPage.find_last(data, pages[0].serial),
                             pages[-1])

    def test_find_last_muxed(self):
        pages = [OggPage() for i in range(10)]
        for i, page in enumerate(pages):
            page.sequence = i
        pages[-2].last = True
        pages[-1].serial = pages[0].serial + 1
        data = BytesIO(b"".join([page.write() for page in pages]))
        self.failUnlessEqual(OggPage.find_last(data, pages[0].serial),
                             pages[-2])

    def test_find_last_no_serial(self):
        pages = [OggPage() for i in range(10)]
        for i, page in enumerate(pages):
            page.sequence = i
        data = BytesIO(b"".join([page.write() for page in pages]))
        self.failUnless(OggPage.find_last(data, pages[0].serial + 1) is None)

    def test_find_last_invalid(self):
        data = BytesIO(b"if you think this is an Ogg, you're crazy")
        self.failUnlessRaises(OggError, OggPage.find_last, data, 0)

    # Disabled because GStreamer will write Oggs with bad data,
    # which we need to make a best guess for.
    #
    # def test_find_last_invalid_sync(self):
    #     data = BytesIO("if you think this is an OggS, you're crazy")
    #     self.failUnlessRaises(OggError, OggPage.find_last, data, 0)

    def test_find_last_invalid_sync(self):
        data = BytesIO(b"if you think this is an OggS, you're crazy")
        page = OggPage.find_last(data, 0)
        self.failIf(page)

    def test_crc_py25(self):
        # Make sure page.write can handle both signed/unsigned int
        # return values of crc32.
        # https://github.com/quodlibet/mutagen/issues/63
        # http://docs.python.org/library/zlib.html#zlib.crc32

        import zlib
        old_crc = zlib.crc32

        def zlib_uint(*args):
            return (old_crc(*args) & 0xffffffff)

        def zlib_int(*args):
            return cdata.int_be(cdata.to_uint_be(old_crc(*args) & 0xffffffff))

        try:
            page = OggPage()
            page.packets = [b"abc"]
            zlib.crc32 = zlib_uint
            uint_data = page.write()
            zlib.crc32 = zlib_int
            int_data = page.write()
        finally:
            zlib.crc32 = old_crc

        self.failUnlessEqual(uint_data, int_data)

    def tearDown(self):
        self.fileobj.close()
コード例 #39
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
    def test_replace(self):
        # create interleaved pages
        fileobj = BytesIO()
        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].serial = 42
        pages[0].sequence = 0
        pages[0].packets = [b"foo"]
        pages[1].serial = 24
        pages[1].sequence = 0
        pages[1].packets = [b"bar"]
        pages[2].serial = 42
        pages[2].sequence = 1
        pages[2].packets = [b"baz"]
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]

        old_pages = [pages_from_file[0], pages_from_file[2]]
        packets = OggPage.to_packets(old_pages, strict=True)
        self.assertEqual(packets, [b"foo", b"baz"])
        new_packets = [b"1111", b"2222"]
        new_pages = OggPage.from_packets(new_packets,
                                         sequence=old_pages[0].sequence)
        self.assertEqual(len(new_pages), 1)
        OggPage.replace(fileobj, old_pages, new_pages)

        fileobj.seek(0, 0)
        first = OggPage(fileobj)
        self.assertEqual(first.serial, 42)
        self.assertEqual(OggPage.to_packets([first], strict=True),
                         [b"1111", b"2222"])
        second = OggPage(fileobj)
        self.assertEqual(second.serial, 24)
        self.assertEqual(OggPage.to_packets([second], strict=True), [b"bar"])
コード例 #40
0
 def _post_tags(self, fileobj):
     page = OggPage.find_last(fileobj, self.serial, finishing=True)
     if page is None:
         raise OggSpeexHeaderError
     self.length = page.position / float(self.sample_rate)
コード例 #41
0
 def test_theora_not_first_page(self):
     with open(self.filename, "rb") as h:
         page = OggPage(h)
     page.first = False
     fileobj = BytesIO(page.write())
     self.failUnlessRaises(error, OggTheoraInfo, fileobj)
コード例 #42
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_invalid_version(self):
     page = OggPage()
     OggPage(BytesIO(page.write()))
     page.version = 1
     self.failUnlessRaises(OggError, OggPage, BytesIO(page.write()))
コード例 #43
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_not_enough_data(self):
     data = OggPage().write()[:-1] + b"\x01\x10"
     self.failUnlessRaises(OggError, OggPage, BytesIO(data))
コード例 #44
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_to_packets_continued(self):
     self.pages[0].continued = True
     self.failUnlessEqual(OggPage.to_packets(self.pages),
                          [b"foo", b"bar", b"baz"])
コード例 #45
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_crappy_fragmentation(self):
     packets = [b"1" * 511, b"2" * 511, b"3" * 511]
     pages = OggPage.from_packets(packets, default_size=510, wiggle_room=0)
     self.failUnless(len(pages) > 3)
     self.failUnlessEqual(OggPage.to_packets(pages), packets)
コード例 #46
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_from_packets_short_enough(self):
     packets = [b"1" * 200, b"2" * 200, b"3" * 200]
     pages = OggPage.from_packets(packets)
     self.failUnlessEqual(OggPage.to_packets(pages), packets)
コード例 #47
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_single_page_roundtrip(self):
     self.failUnlessEqual(
         self.page, OggPage(BytesIO(self.page.write())))
コード例 #48
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_first_metadata_page_is_separate(self):
     self.failIf(OggPage(self.fileobj).continued)
コード例 #49
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_from_packets_long(self):
     packets = [b"1" * 100000, b"2" * 100000, b"3" * 100000]
     pages = OggPage.from_packets(packets)
     self.failIf(pages[0].complete)
     self.failUnless(pages[1].continued)
     self.failUnlessEqual(OggPage.to_packets(pages), packets)
コード例 #50
0
 def __init__(self, fileobj, info):
     pages = self.__get_comment_pages(fileobj, info)
     data = OggPage.to_packets(pages)[0][8:]  # Strip OpusTags
     super(OggOpusVComment, self).__init__(data, framing=False)
コード例 #51
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_page_max_size_alone_too_big(self):
     page = OggPage()
     page.packets = [b"1" * 255 * 255]
     page.complete = True
     self.failUnlessRaises(ValueError, page.write)
コード例 #52
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_complete_zero_length(self):
     packets = [b""] * 20
     page = OggPage.from_packets(packets)[0]
     new_page = OggPage(BytesIO(page.write()))
     self.failUnlessEqual(new_page, page)
     self.failUnlessEqual(OggPage.to_packets([new_page]), packets)
コード例 #53
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_find_last_invalid_sync(self):
     data = BytesIO(b"if you think this is an OggS, you're crazy")
     page = OggPage.find_last(data, 0)
     self.failIf(page)
コード例 #54
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_too_many_packets(self):
     packets = [b"1"] * 3000
     pages = OggPage.from_packets(packets)
     map(OggPage.write, pages)
     self.failUnless(len(pages) > 3000 // 255)
コード例 #55
0
ファイル: test_ogg.py プロジェクト: erdoukki/mutagen
 def test_flags_next_page(self):
     page = OggPage(self.fileobj)
     self.failIf(page.first)
     self.failIf(page.continued)
     self.failIf(page.last)
コード例 #56
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
 def test_read_max_size(self):
     page = OggPage()
     page.packets = [b"1" * 255 * 255]
     page.complete = False
     page2 = OggPage()
     page2.packets = [b"", b"foo"]
     page2.sequence = 1
     page2.continued = True
     data = page.write() + page2.write()
     fileobj = BytesIO(data)
     self.failUnlessEqual(OggPage(fileobj), page)
     self.failUnlessEqual(OggPage(fileobj), page2)
     self.failUnlessRaises(EOFError, OggPage, fileobj)
コード例 #57
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
    def test_replace_fast_path(self):
        # create interleaved pages
        fileobj = BytesIO()
        pages = [OggPage(), OggPage(), OggPage()]
        pages[0].serial = 42
        pages[0].sequence = 0
        pages[0].packets = [b"foo"]
        pages[1].serial = 24
        pages[1].sequence = 0
        pages[1].packets = [b"bar"]
        pages[2].serial = 42
        pages[2].sequence = 1
        pages[2].packets = [b"baz"]
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]

        old_pages = [pages_from_file[0], pages_from_file[2]]
        packets = OggPage.to_packets(old_pages, strict=True)
        self.assertEqual(packets, [b"foo", b"baz"])
        new_packets = [b"111", b"222"]
        new_pages = OggPage._from_packets_try_preserve(new_packets, old_pages)
        self.assertEqual(len(new_pages), 2)

        # remove insert_bytes, so we can be sure the fast path was taken
        old_insert_bytes = _util.insert_bytes
        _util.insert_bytes = None
        try:
            OggPage.replace(fileobj, old_pages, new_pages)
        finally:
            _util.insert_bytes = old_insert_bytes

        # validate that the new data was written and the other pages
        # are untouched
        fileobj.seek(0, 0)
        pages_from_file = [
            OggPage(fileobj),
            OggPage(fileobj),
            OggPage(fileobj)
        ]
        packets = OggPage.to_packets([pages_from_file[0], pages_from_file[2]],
                                     strict=True)
        self.assertEqual(packets, [b"111", b"222"])
        packets = OggPage.to_packets([pages_from_file[1]], strict=True)
        self.assertEqual(packets, [b"bar"])
コード例 #58
0
 def test_theora_not_first_page(self):
     page = OggPage(open(self.filename, "rb"))
     page.first = False
     fileobj = cBytesIO(page.write())
     self.failUnlessRaises(IOError, OggTheoraInfo, fileobj)
コード例 #59
0
ファイル: oggopus.py プロジェクト: AyomP/dailyfresh
 def _post_tags(self, fileobj):
     page = OggPage.find_last(fileobj, self.serial, finishing=True)
     if page is None:
         raise OggOpusHeaderError
     self.length = (page.position - self.__pre_skip) / float(48000)
コード例 #60
0
ファイル: test_ogg.py プロジェクト: tomjohnhall/mutagen
    def test_replace_continued(self):
        # take a partial packet and replace it with a new page
        # replace() should make it spanning again
        fileobj = BytesIO()
        pages = [OggPage(), OggPage()]
        pages[0].serial = 1
        pages[0].sequence = 0
        pages[0].complete = False
        pages[0].packets = [b"foo"]
        pages[1].serial = 1
        pages[1].sequence = 1
        pages[1].continued = True
        pages[1].packets = [b"bar"]
        fileobj = BytesIO()
        for page in pages:
            fileobj.write(page.write())

        fileobj.seek(0, 0)
        pages_from_file = [OggPage(fileobj), OggPage(fileobj)]
        self.assertEqual(OggPage.to_packets(pages_from_file), [b"foobar"])
        packets_part = OggPage.to_packets([pages_from_file[0]])
        self.assertEqual(packets_part, [b"foo"])
        new_pages = OggPage.from_packets([b"quuux"])
        OggPage.replace(fileobj, [pages_from_file[0]], new_pages)

        fileobj.seek(0, 0)
        written = OggPage.to_packets([OggPage(fileobj), OggPage(fileobj)])
        self.assertEquals(written, [b"quuuxbar"])