用python写的一个mp3的tag解析

最新推荐文章于 2025-03-25 14:07:59 发布
最新推荐文章于 2025-03-25 14:07:59 发布
阅读量2.1k 收藏
点赞数
分类专栏： Python
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zqm175899960/article/details/10008665
版权

最近在研究mp3的tag解析，由于涉及到编码的问题，我使用了python作为开发语言，解析了id3v2和id3v1格式的Mp3，计算时长对于定码率的mp3管用

# -*- coding: utf-8 -*-  
# coding=utf-8  
'''
Created on 2013-8-8

@author: zqm
'''

import struct;
import re;

class ID3_Mp3Parser:
    def __init__(self):
        self.ID3V2Tag = False; 
        self.ID3V1Tag = False;
        self.ID3V2TagLen = 10;
        self.ID3V2Tags = {};
        self.ID3V1Tags = [];
        self.HeaderSize = 3;
        self.VerSize = 1;
        self.RevisionSize = 1;
        self.FlagSize = 1;
        self.LenSize = 4;
        self.Type = -1; 
        self.TagNameSize = 4;
        self.TagFlagSize = 2;
        self.CodeString = ['gbk', 'UTF_16', 'UTF_16BE', 'UTF_8'];
        self.MPEGLIST = ('MPEG2.5', None, 'MPEG2', 'MPEG1');
        self.LAYERLIST = (None, 'Layer 3', 'Layer 2', 'Layer 1');
        self.patten = re.compile(r'\w+');
                
        self.MPEG1_LAYER1 = [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, -1];
        self.MPEG1_LAYER2 = [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, -1];
        self.MPEG1_LAYER3 = [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, -1];
        self.MPEG1 = [self.MPEG1_LAYER1, self.MPEG1_LAYER2, self.MPEG1_LAYER3];
        
        self.MPEG12_2P5_LAYER1 = [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, -1];
        self.MPEG12_2P5_LAYER2_3 = [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, -1];
        self.MPEG12_2P5 = [self.MPEG12_2P5_LAYER1, self.MPEG12_2P5_LAYER2_3, self.MPEG12_2P5_LAYER2_3];
        
        self.Bitrary = [self.MPEG1, self.MPEG12_2P5];
        
        self.MPEG1_SAMPLE = [44100, 48000, 32000, 0];
        self.MPEG2_SAMPLE = [22050, 24000, 16000, 0];
        self.MPEG3_SAMPLE = [11025, 12000, 8000, 0];
        
        self.Sample = [self.MPEG1_SAMPLE, self.MPEG2_SAMPLE, self.MPEG3_SAMPLE];
        
        self.LAYER1_SIZE = [384, 384, 384];
        self.LAYER2_SIZE = [1152, 1152, 1152];
        self.LAYER3_SIZE = [1152, 576, 576];
        
        self.LAYER_SIZE = [self.LAYER1_SIZE, self.LAYER2_SIZE, self.LAYER3_SIZE];
        
    def HasID3V2Tag(self):
        self.fd.seek(0, 0);  # move start of file
        self.ID3V2Header = self.fd.read(self.HeaderSize);
        if self.ID3V2Header is None or len(self.ID3V2Header) != self.HeaderSize:
            return False;
        elif self.ID3V2Header == "ID3":
            return True;
        return False;
    
    def HasID3V1Tag(self):
        self.fd.seek(0, 2);  # seek to file end
        if self.fd.tell() < 128:
            return False;
        self.fd.seek(-128, 1);  # seek to -128 from end
        self.ID3V1Header = self.fd.read(self.HeaderSize);
        if self.ID3V1Header is None or len(self.ID3V1Header) != self.HeaderSize:
            return False;
        elif self.ID3V1Header == "TAG":
            return True;
        return False;
        
    def ParseHead(self):
        if self.fd.closed:
            return False;
        if self.HasID3V2Tag():
            self.ID3V2Tag = True;
            self.GetVerison();
        if self.HasID3V1Tag():
            self.ID3V1Tag = True;
        if self.ID3V1Tag or self.ID3V2Tag:
            return True;
        return False;
    
    def ParseID3V1Tag(self):
        self.fd.seek(-125, 2);
        tagName = self.fd.read(32 - 3 + 1);
        self.ID3V1Tag_Title = tagName.decode('gbk');
        tagName = self.fd.read(62 - 33 + 1);
        self.ID3V1Tag_Artist = tagName.decode('gbk');
        tagName = self.fd.read(92 - 63 + 1);
        self.ID3V1Tag_Album = tagName.decode('gbk');
        tagName = self.fd.read(96 - 93 + 1);
        self.ID3V1Tag_Date = tagName.decode('gbk');
        tagName = self.fd.read(126 - 97 + 1);
        self.ID3V1Tag_Remark = tagName.decode('gbk');
        tagName = self.fd.read(127 - 127 + 1);
        self.ID3V1Tag_Category = ord(tagName);
        self.ID3V1Tags = [self.ID3V1Tag_Title, self.ID3V1Tag_Artist, self.ID3V1Tag_Album, self.ID3V1Tag_Date, \
                         self.ID3V1Tag_Remark, self.ID3V1Tag_Category];
    
    def ParseID3V2Tag(self):
        TagAllLen = self.HeaderLen;
        self.fd.seek(self.ID3V2TagLen, 0);
        while(TagAllLen > 0):
            tagName = self.fd.read(self.TagNameSize);
            tagLen = self.fd.read(self.LenSize);            
            self.fd.read(self.TagFlagSize);
            if len(tagName.strip()) > 0 and re.match(self.patten, tagName):               
                nTagLen = self.BigToLittle(tagLen);
                strTitle = self.fd.read(nTagLen);
                if (nTagLen > 1) and (len(strTitle) == nTagLen) and tagName != "APIC":
                    strTitle = self.GetNameString(strTitle);
                    self.ID3V2Tags[tagName] = strTitle;
            TagAllLen -= (4 + 4 + 2 + nTagLen);
        
    def ParseLayerInfo(self):
        if self.ID3V2Tag:
            self.bodyOffset = self.HeaderLen + self.ID3V2TagLen;
        else:
            self.bodyOffset = 0;
        self.fd.seek(0, 0);
        self.fd.seek(self.bodyOffset, 0);
        twobytes = self.fd.read(4);  # read four bytes
        (a, b, c, d) = struct.unpack('cccc', twobytes);
        nMpeg = self.GetValueFromBytesBetween(b, 3, 5);
        nLayer = self.GetValueFromBytesBetween(b, 1, 3);
        nBitrary = self.GetValueFromBytesBetween(c, 4, 8);
        nSample = self.GetValueFromBytesBetween(c, 2, 4);
        self.nChannel = self.GetValueFromBytesBetween(d, 6, 8);
        nFill = self.GetValueFromBytesBetween(c, 1, 2);
        nLayerSampleNum = self.GetLayerSampleNum(nMpeg, nLayer);      
        nBitrary = self.GetBitrary(nMpeg, nLayer, nBitrary);
        nSample = self.GetSample(nMpeg, nLayer, nSample);
#        print self.GetChannelString(nChannel);
#        print self.MPEGLIST[nMpeg];
#        print self.LAYERLIST[nLayer];
        nLayerSize = self.GetPerLayerLength(nMpeg, nLayer, nLayerSampleNum, nSample, nBitrary, nFill);
        self.LayerNum = self.GetLayerNum(nLayerSize);
        self.TotalTime = self.LayerNum * nLayerSampleNum / nSample;
        print '(%d:%d)'%(self.TotalTime/60,self.TotalTime%60);
        
    def GetLayerNum(self, nLayerSize):
        self.fd.seek(0, 2);
        total = self.fd.tell();
        contentSize = total - self.bodyOffset;
        if self.ID3V1Tag:
            contentSize -= 128;
        if nLayerSize != 0:
            return contentSize / nLayerSize;
        return 0;
    
    def GetPerLayerLength(self, nMpeg, nLayer, nLayerSampleNum, nSample, nBitrary, nFill):
        (mpeg_index, layer_index) = self.GetMpegAndLayerIndex(nMpeg, nLayer);
        if mpeg_index is None or layer_index is None:
            return -1;    
        layerLen = nLayerSampleNum * nBitrary * 1000 / (nSample * 8);
        if layer_index == 0:
            layerLen += nFill * 4;
        else:
            layerLen += nFill;
        return layerLen;
        
    def GetLayerSampleNum(self, nMpeg, nLayer):
        (mpeg_index, layer_index) = self.GetMpegAndLayerIndex(nMpeg, nLayer);
        if mpeg_index is None or layer_index is None:
            return -1;       
        return self.LAYER_SIZE[layer_index][mpeg_index];
        
    def GetChannelString(self, nChannel):
        if nChannel == 0:
            return '立体声';
        elif nChannel == 1:
            return '联合立体声(立体声)';
        elif nChannel == 2:
            return '双声道(立体声)';
        else:
            return '单声道(单身)';
    
    
    def GetMpegAndLayerIndex(self, nMpeg, nLayer):
        if nMpeg == 3:  # mpeg 2
            mpeg_index = 0;
        elif nMpeg == 2:
            mpeg_index = 1;
        elif nMpeg == 0:
            mpeg_index = 2;
        layer_index = 3 - nLayer;
        
        if mpeg_index < 0 or layer_index == 0:
            return (None, None);
        
        return (mpeg_index, layer_index);
    
    def GetBitrary(self, nMpeg, nLayer, nIndex):
        (mpeg_index, layer_index) = self.GetMpegAndLayerIndex(nMpeg, nLayer);
        if mpeg_index is None or layer_index is None:
            return -1;       
        if mpeg_index != 0:
            mpeg_index = 1;
        return self.Bitrary[mpeg_index][layer_index][nIndex];
    
    def GetSample(self, nMpeg, nLayer, nIndex):
        (mpeg_index, layer_index) = self.GetMpegAndLayerIndex(nMpeg, nLayer);
        if mpeg_index is None or layer_index is None:
            return -1;       
        return self.Sample[mpeg_index][nIndex];
        
    def GetMPEG(self, byts):
        mpeg = (ord(byts) >> 3) & (0x3);
        return mpeg;
    
    def GetLayer(self, byts):
        layer = (ord(byts) >> 1) & (0x3);
        return layer;
    def GetValueFromBytesBetween(self, byts, startIndex, endIndex):
        val = 0;
        if endIndex <= startIndex or endIndex > 8 or startIndex < 0:
            return val;
        nVal = ord(byts);  # convert to int
        nVal = nVal >> startIndex;
        nLen = endIndex - startIndex;
        i = 0
        t = 1;
        v = 0;
        while i < nLen:
            v += t;
            i += 1;
            t *= 2;
        val = nVal & v;
        return val;
                
    def GetNameString(self, string):
        codeIndex = ord(string[0]);
        code = self.CodeString[codeIndex];
        return string[1:].decode(code);
        
    def BigToLittle(self, strNum):
        (a0, a1, a2, a3) = struct.unpack('cccc', strNum);
        tmp = a0;
        a0 = a3;
        a3 = tmp;
        tmp = a1;
        a1 = a2;
        a2 = tmp;
        n = struct.pack('cccc', a0, a1, a2, a3);
        nRet = struct.unpack('I', n)[0];
        return nRet;
    
    def GetVerison(self):
        Ver = self.fd.read(self.VerSize);
        self.Ver = self.GetIntegerFromByte(Ver); 
        if self.Ver == 3:
            self.Type = 1;  # ID3V2.3
        elif self.Ver == 4:
            self.Type = 2;  # ID3V2.4
        if self.Type == -1:
            return False;
        Revision = self.fd.read(self.RevisionSize);
        self.Revision = self.GetIntegerFromByte(Revision);
        Flag = self.fd.read(self.FlagSize);
        self.Flag = self.GetIntegerFromByte(Flag);
        Len = self.fd.read(self.LenSize);
        self.HeaderLen = self.GetMp3HeadLength(Len);
        return True;
    
    def GetMp3HeadLength(self, Len):
        IntArray = [];
        nArray = struct.unpack('cccc', Len);
        for c in nArray:
            n = ord(c);
            IntArray.append(n);
        return self.CalcMp3TagLength(IntArray);
        
    def CalcMp3TagLength(self, nIntArray):
        Size = (nIntArray[0] & 0x7F) * 0x200000 + (nIntArray[1] & 0x7F) * 0x4000\
         + (nIntArray[2] & 0x7F) * 0x80 + (nIntArray[3] & 0x7F);
        return Size;
    
    def GetIntegerFromByte(self, byte):
        try:
            tmp = struct.unpack('c', byte)[0];
            ret = ord(tmp);
        except:
            ret = 0;
        return ret;
        
    def Parse(self, filePath):
        if filePath is None or len(filePath) == 0:
            return False;
        self.fd = open(filePath, "rb+");
        if self.ParseHead() != True:
            print 'not id3'
        else:
            if self.ID3V2Tag:
                self.ParseID3V2Tag();              
            if self.ID3V1Tag:
                self.ParseID3V1Tag();
            self.ParseLayerInfo();
        self.fd.close();
        return True;


Python解析网页
2302_79100751的博客
05-22 1333
Beautiful Soup简介以及安装与配置 解析器 解析数据 遍历文档树 节点 find css选择器
Python-MusicTag允许您下载所需的所有音乐并自动设置ID3标签
08-10
MusicTag-MusicTag allows you to download from YouTube all the music you want and automatically set the ID3 tags
Python实例获取mp3文件的tag信息
weixin_33859231的博客
03-22 641
下面利用一个python的实例程序，来学习python。这个程序的目的就是分析出所有MP3文件的Tag信息并输出。 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 ...
Python 解析 MP3 文件元数据（mutagen 库）
最新发布
2501_91246211的博客
03-25 193
```htmlPython 解析 MP3 文件元数据（mutagen 库）在处理音频文件时，我们经常需要读取或修改文件的元数据信息，如标题、艺术家、专辑等。对于MP3文件，我们可以使用Python中的一个强大库——mutagen来完成这项任务。首先，我们需要安装mutagen库。打开命令行工具，输入以下命令进行安装： 读取 MP3 文件元数据 安装完成后，我们可以开始编写代码如下：
编写Python脚本来获取mp3文件tag信息的教程
会飞的程序猿的博客
03-05 1499
def stripnulls(data):  "一个空字符串的处理函数将所有00字节的内容替换为空字符，病将前后的空字符串去掉"  # Python中的strip用于去除字符串的首尾字符，同理，lstrip用于去除左边的字符，rstrip用于去除右边的字符。  return data.replace("\00", "").strip()  class FileInfo(UserDict):  ''...
Android 播放mp3 tag乱码分析之jni 篇
念茜的博客
02-14 4806
 Android media 扫描mp3文件这个重任是cpp来完成的。但是tag解析工作是上层java完成的。乱码问题的根源是： java内部是使用16bit的unicode编码（UTF-16）来表示字符串的，无论中文英文都是2字节； jni内部是使用UTF-8编码来表示字符串的，UTF-8是变长编码的unicode，一般ascii字符是1字节，中文是3字节； c/c++使用的是原始数据，ascii就是一个字节了，中文一般是GB2312编码，用两个字节来表示一个汉字。 解决办法是：jni返回给java的字符
使用 python3 批量修改歌曲 mp3tags
das2m
08-05 670
从网络上下载的音频一般都有网站的 tags 在里面，导入 Apple Music 或者 播放器 时显得很乱，可以使用 eyed3 库来批量修改。 #!/usr/bin/env python #coding:utf-8 # 用 python3 批量修改 mp3tags # use: python id3.py path import os import re import sys import eyed3 if __name__ == "__main__": if len(sys.argv)!=
python 解析XML python模块xml.dom解析xml实例代码
12-24
本文将深入探讨如何使用`xml.dom.minidom`解析XML文件，并提供一个具体的实例代码。 `xml.dom.minidom`是Python中的一个DOM（Document Object Model）解析器，它允许开发者以对象的形式操作XML文档。DOM是一种标准...
Python解析cdd 文件和批量删除CANoe工程cbf文件
06-05
本主题主要关注两个方面：使用Python解析CDD文件和批量删除CANoe工程中的CBF文件。CDD（Configuration Data Description）文件是用于描述CANoe工程配置的数据文件，而CBF（CAN Bus Format）文件则是CANoe中存储CAN...
python解析xml文件方式(解析、更新、写入)
01-21
使用的是python的xml.dom.minidom包，详情可见其官方文档：xml.dom.minidom官方文档。全文都将围绕以下的customer.xml进行操作： <?xml version=1.0 encoding=utf-8 ?> <!-- This is list of customers --...
mp3 id3tag 解析源码
11-01
mp3 id3 tag解析　可获得文件内封面图片，演唱者，歌曲名称等信息
MP3TAG
02-23
读取SONGBAK。DBF 数据库，根据编号来查找文件，找到文件后，写入TAG信息：歌名、歌星、出版单位、说明，并重命名文件名。使用了文件存在检查函数，目录函数，移动函数，改名函数,MP3控件库（安腾写）数据库组件是由BDE支持的
Python文件——MP3示例
06-04
Python基础——文件中的读取文件中的MP3文件示例，有兴趣的朋友可以下载进行尝试。
MP3ID3V2TAG源码
12-30
MP3ID3V2TAG源码，提取MP3ID3V2信息
python爬虫教程：编写Python脚本来获取mp3文件tag信息的教程
python爬虫开发教程
03-22 1024
这篇文章主要介绍了编写Python脚本来获取mp3文件tag信息的教程,代码基于Python2.x,文中的注释很详细,需要的朋友可以参考下 下面利用一个python的实例程序，来学习python。这个程序的目的就是分析出所有MP3文件的Tag信息并输出。 import os # 导入os模块，提供文件路径，列出文件等方法 import sys # 导入sys模块，使用sys.modules获取模块...
python解析html tag
叶玄青的博客
10-25 1803
有时候网页上信息太多，一方面用肉眼看容易出错，另一方面点击了网页的链接之后，原来页面的信息就被刷新了，这时候如果能通过程序自动的分析网页上的信息就好了，python的HTMLParser能够很好的解决这个问题，当然它只是把内容抓取下来，具体分析还得看不同人的需求。from HTMLParser import HTMLParserclass MyHTMLParser(HTMLParser):
C#获取mp3 Tag信息
ctthen的专栏
06-19 3642
//Foxer_Player_App_Author: CT.ThEN//Foxer_Player_App_BuildTime: Otc,12,2008//Foxer_Player_App_Version: 1.01//Foxer_Player_App_Author_email: ctthen@126.com//Foxer_Player_mp3Info:get_mp3Info
写一个python der编码解析的示例
04-20
当然可以！Python中提供了很方便的模块处理DER编码，下面是一个简单的示例代码： ```python import binascii import struct # DER编码数据 der_data = binascii.unhexlify('3081a9020100300d060964686f6d656b697461020101300f06035504031308436f6d707574696e67021000') # 解析DER编码 def parse_der(data): i = 0 while i < len(data): tag = data[i] i += 1 if tag & 0x1f == 0x1f: # 标签号需要两个字节 tag = (tag << 8) | data[i] i += 1 length = data[i] i += 1 if length & 0x80 == 0x80: # 长度需要多个字节 length_bytes = length & 0x7f length = 0 for j in range(length_bytes): length = (length << 8) | data[i] i += 1 value = data[i:i+length] i += length yield tag, value # 解析DER编码示例 for tag, value in parse_der(der_data): if tag == 0x06: # Object Identifier 标签号 oid = '.'.join(str(b) for b in value) print('Object Identifier:', oid) elif tag == 0x03: # Bit String 标签号 unused_bits = value[0] data = value[1:] print('Bit String (unused bits = {}):'.format(unused_bits), binascii.hexlify(data).decode('utf-8')) elif tag == 0x13: # PrintableString 标签号 print('Printable String:', value.decode('utf-8')) ``` 这段代码可以解析DER编码格式的数据，并打印出其中的Object Identifier、Bit String、Printable String等元素。需要注意的是，这里的数据是以16进制字符串形式输入的，需要通过binascii模块的unhexlify函数转换为二进制数据。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值