phlsM3U8-downner 0.1.0__tar.gz

phlsm3u8_downner-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Error
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

phlsm3u8_downner-0.1.0/PKG-INFO

@@ -0,0 +1,90 @@
+Metadata-Version: 2.5
+Name: phlsM3U8_downner
+Version: 0.1.0
+Summary: Async HLS/m3u8 downloader with AES-128 decryption and ffmpeg merging
+Project-URL: Homepage, https://github.com/ap945/phlsM3U8_downner
+Author: Error
+License-Expression: MIT
+License-File: LICENSE
+Keywords: aes-128,downloader,ffmpeg,hls,m3u8,segment
+Classifier: Natural Language :: Chinese (Simplified)
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Multimedia :: Video
+Requires-Python: >=3.10
+Requires-Dist: aiofiles
+Requires-Dist: aiohttp
+Requires-Dist: ffmpeg-python
+Requires-Dist: pycryptodome
+Requires-Dist: rich
+Requires-Dist: tenacity
+Description-Content-Type: text/markdown
+
+# phlsM3U8_downner
+
+Async HLS/m3u8 downloader with AES-128 decryption and ffmpeg merging.
+支持主播放列表自动选择清晰度、切片并发下载、AES-128 解密、ffmpeg 无损合并.
+
+## Install
+
+    pip install phlsM3U8_downner
+
+Requires **ffmpeg** on system PATH:
+Windows `winget install ffmpeg` · macOS `brew install ffmpeg` · Linux `sudo apt install ffmpeg`
+
+## Usage
+
+    from phlsm3u8down import DownAndMerge
+
+    results = DownAndMerge(UrlAndName={"https://example.com/v.m3u8" : "1.mp4"})
+    r = results["1.mp4"]
+    print(r.segments_succeeded, "/", r.segments_total)
+    print(r.output_path, r.file_size_bytes)
+
+## More Usage
+    - Config:
+        in config_set 它含有很多配置项,见下:
+    ————————————————                    ————————————————————————————
+    concurrency: int = 20               # 同时下载几个切片
+    limit : int = 20                    #最大请求数量
+    timeout: float = 30.0               # 单个切片的超时秒数
+    retries: int = 3                    # 单个切片失败重试次数
+    retry_backoff: float = 1.5          # 重试间隔倍数:1s → 1.5s → 2.25s(指数退避）
+    stop_after_delay : float | int =15  #设置整个重试过程的最大耗时
+    verify_ssl: bool = False            # 是否校验 SSL(下载站证书经常有问题,默认关)
+    keep_segments: bool = False         # 合并成功后是否保留 ts 文件(False=清理）
+    breakpoint_request : bool =False    #加载上次下载未完成的文件重下(True为重下)
+    quiet : bool=False                  #安静模式
+    method : str = 'get'                #请求方式
+    key_method : str = 'get'           #请求方式
+    data_path : str|Path = str(Path.cwd() /'hls_downloads') #user_data的位置(存放ts/m4s/mp4媒体文件和data.json)
+    Wait_Merge : bool =True          #等下载全部成功再合并(false是不等)
+    Rich : bool =True                   #显示进度条(默认是)
+    ——————————————————                      ————————————————————————
+        -config_set注意事项:
+            -如果你想使用breakpoint_request,这需要data,json中失败的片段(failed_segments/key_errors)不为[],否则什么都不会发生
+            -等你下载了一个文件后会自动刷新,需要注意的是,**phlsM3U8_downner会覆盖原有内容**
+            -quiet 这个设置如果为True,那么将会少很多打印,甚至连进度条都不会输出
+            -key_method method,method是为普通切片(segment)文件请求的模式,而key_method是专门为key请求的模式,在某一些场景中他很有用,你可以使他们全部为**'get'**
+            -Wait_Merge 如果你设置了True,那么他不会去管data.json中失败的片段反而会去将成功的片段合并,这可能会使合并后的视频缺斤少两
+
+    - resolver:
+        -defined_decode中 **defined_method**是自定义加密模式但是可能phlsM3U8_downner不支持(目前只支持AES-128加密,但是这够了)
+
+        -你可以使用**defined_func**参数来存放你的函数**{key_url:函数名称}**,phlsM3U8_downner会用你的函数来解密
+
+        -如果获取的key有加密,你可以使用encrypto_key**{key_url:函数名称}**来解密你的key
+
+        -如果phlsM3U8_downner获取不到key,例如DRM中,你可以使用**defined_key**来放你获取到的key(bytes),如果你放了**defined_key**,那请你务必需将**defined_iv**也补充上去**{key_url:函数名称}**,虽然phlsM3U8_downner内置了采用序列号的方式来替换iv但是这是一个保险
+
+        (resolver.defined_method Method resolver.defined_func func resolver.encrypto_key encrypto_key resolver.defined_iv iv resolver.defined_key key)
+## Notes
+- 不要同时对多个下载使用同一个输出文件名（后者会覆盖前者）
+- 多个主播放列表同时下载时需手动选清晰度，建议逐个下载
+- 配置项见 `config_set.config`（IDE 悬浮即可查看全部字段）
+
+
+
+## 0.1.0 first release

phlsm3u8_downner-0.1.0/README.md

@@ -0,0 +1,66 @@
+# phlsM3U8_downner
+
+Async HLS/m3u8 downloader with AES-128 decryption and ffmpeg merging.
+支持主播放列表自动选择清晰度、切片并发下载、AES-128 解密、ffmpeg 无损合并.
+
+## Install
+
+    pip install phlsM3U8_downner
+
+Requires **ffmpeg** on system PATH:
+Windows `winget install ffmpeg` · macOS `brew install ffmpeg` · Linux `sudo apt install ffmpeg`
+
+## Usage
+
+    from phlsm3u8down import DownAndMerge
+
+    results = DownAndMerge(UrlAndName={"https://example.com/v.m3u8" : "1.mp4"})
+    r = results["1.mp4"]
+    print(r.segments_succeeded, "/", r.segments_total)
+    print(r.output_path, r.file_size_bytes)
+
+## More Usage
+    - Config:
+        in config_set 它含有很多配置项,见下:
+    ————————————————                    ————————————————————————————
+    concurrency: int = 20               # 同时下载几个切片
+    limit : int = 20                    #最大请求数量
+    timeout: float = 30.0               # 单个切片的超时秒数
+    retries: int = 3                    # 单个切片失败重试次数
+    retry_backoff: float = 1.5          # 重试间隔倍数:1s → 1.5s → 2.25s(指数退避）
+    stop_after_delay : float | int =15  #设置整个重试过程的最大耗时
+    verify_ssl: bool = False            # 是否校验 SSL(下载站证书经常有问题,默认关)
+    keep_segments: bool = False         # 合并成功后是否保留 ts 文件(False=清理）
+    breakpoint_request : bool =False    #加载上次下载未完成的文件重下(True为重下)
+    quiet : bool=False                  #安静模式
+    method : str = 'get'                #请求方式
+    key_method : str = 'get'           #请求方式
+    data_path : str|Path = str(Path.cwd() /'hls_downloads') #user_data的位置(存放ts/m4s/mp4媒体文件和data.json)
+    Wait_Merge : bool =True          #等下载全部成功再合并(false是不等)
+    Rich : bool =True                   #显示进度条(默认是)
+    ——————————————————                      ————————————————————————
+        -config_set注意事项:
+            -如果你想使用breakpoint_request,这需要data,json中失败的片段(failed_segments/key_errors)不为[],否则什么都不会发生
+            -等你下载了一个文件后会自动刷新,需要注意的是,**phlsM3U8_downner会覆盖原有内容**
+            -quiet 这个设置如果为True,那么将会少很多打印,甚至连进度条都不会输出
+            -key_method method,method是为普通切片(segment)文件请求的模式,而key_method是专门为key请求的模式,在某一些场景中他很有用,你可以使他们全部为**'get'**
+            -Wait_Merge 如果你设置了True,那么他不会去管data.json中失败的片段反而会去将成功的片段合并,这可能会使合并后的视频缺斤少两
+
+    - resolver:
+        -defined_decode中 **defined_method**是自定义加密模式但是可能phlsM3U8_downner不支持(目前只支持AES-128加密,但是这够了)
+
+        -你可以使用**defined_func**参数来存放你的函数**{key_url:函数名称}**,phlsM3U8_downner会用你的函数来解密
+
+        -如果获取的key有加密,你可以使用encrypto_key**{key_url:函数名称}**来解密你的key
+
+        -如果phlsM3U8_downner获取不到key,例如DRM中,你可以使用**defined_key**来放你获取到的key(bytes),如果你放了**defined_key**,那请你务必需将**defined_iv**也补充上去**{key_url:函数名称}**,虽然phlsM3U8_downner内置了采用序列号的方式来替换iv但是这是一个保险
+
+        (resolver.defined_method Method resolver.defined_func func resolver.encrypto_key encrypto_key resolver.defined_iv iv resolver.defined_key key)
+## Notes
+- 不要同时对多个下载使用同一个输出文件名（后者会覆盖前者）
+- 多个主播放列表同时下载时需手动选清晰度，建议逐个下载
+- 配置项见 `config_set.config`（IDE 悬浮即可查看全部字段）
+
+
+
+## 0.1.0 first release

phlsm3u8_downner-0.1.0/phlsM3U8_downner/Download_Manage.py

@@ -0,0 +1,267 @@
+from pathlib import Path
+from typing import Optional,Any
+from urllib.parse import urljoin
+from Cryptodome.Cipher import AES
+from rich.progress import Progress
+from dataclasses import dataclass, field
+from Cryptodome.Util.Padding import unpad
+import asyncio, aiohttp, aiofiles , time, logging
+from tenacity import retry, stop_after_attempt, stop_after_delay,wait_exponential, retry_if_exception_type, AsyncRetrying
+from . import config as config, resolver, exceptions,models
+
+
+
+"""这个是用来控制经过"main.py"处理后的url进行下载, 合并管理的(主要是控制多线程数量和请求数量, 控制一下子下载多少个m3u8文件)"""
+@dataclass
+class downloader:
+    _request : aiohttp.client.ClientSession 
+    outname : str 
+    segment_lists : list =field(default_factory=list)
+    config : Optional[config.config] =None
+    defined_key : Optional[resolver.defined_decode] = None
+    headers : dict =None
+    json : Any =None
+    data : Any =None
+    task : int =None
+    progress : Progress =field(default_factory=Progress)
+    def __post_init__(self):
+        if self.defined_key is None:
+             self.defined_key=resolver.defined_decode()
+        if self.config is None:
+             self.config=config.config()
+        self.logger=logging.getLogger(__name__)
+        self._segment_list=[]
+        self.start_time=time.time()
+        self.lock=asyncio.Lock()
+        self.semaphore = asyncio.Semaphore(self.config.concurrency)
+        self.ts_list=[]
+        self.path = Path(self.config.data_path)
+        self.key_session=getattr(self._request,self.config.key_method.lower()) 
+        self.Session=getattr(self._request,self.config.method.lower())
+        self.key_dic={}
+        self.map_list=[]
+        self.FailedSegments=[]
+        self.FailedKey=[]#key下载失败
+        self.Bad_key=[]#解密失败
+        self.attempts=self.config.retries
+        self.retryer = AsyncRetrying(
+            stop=(stop_after_attempt(self.attempts) | stop_after_delay(self.config.stop_after_delay)),
+            wait=wait_exponential(multiplier=1, exp_base=self.config.retry_backoff, min=1, max=10),
+            retry=retry_if_exception_type((aiohttp.ClientError, asyncio.TimeoutError)),
+            reraise=True,               # 抛原始异常
+            before_sleep=self._on_retry, # 重试前的钩子
+        )
+    def _on_retry(self, retry_state):
+        if self.config.quiet:
+            return
+        exc = retry_state.outcome.exception() if retry_state.outcome else None
+        url = retry_state.args[0] if retry_state.args else '?'
+        self.progress.console.print(
+            f"[yellow]⚠ {str(url)[:80]} 第 {retry_state.attempt_number} 次失败，准备重试: {exc!r}"
+    )
+
+    
+    async def _down(self, url : str, headers : dict =None)->tuple:    #下载内容
+            if self.config.method.lower()=='get':
+                async with self.Session(url, headers=headers) as response:
+                    response.raise_for_status()
+                    data = await response.read()
+                    return data, True
+            elif self.config.method.lower()=='post':
+                async with self.Session(url, headers=headers, data=self.data, json=self.json) as response:
+                        response.raise_for_status()
+                        data = await response.read()
+                        return data,True
+            else: raise exceptions.GetMethodError(method=self.config.method.lower(),reason='Wrong Method for getting data')
+
+    async def key_down(self, url : str, headers : dict =None):    #下载内容
+        if self.config.key_method.lower()=='get':
+            async with self.key_session(url, headers=headers) as response:
+                response.raise_for_status()
+                data = await response.read()
+                return data
+        elif self.config.key_method.lower()=='post':
+            async with self.key_session(url, headers=headers, data=self.data, json=self.json) as response:
+                    response.raise_for_status()
+                    data = await response.read()
+                    return data
+        else: raise exceptions.GetMethodError(method=self.config.method.lower(),reason='Wrong Method for getting data')
+
+    async def _down_with_retry(self, url : str,  headers : dict =None)->tuple:
+            data, b=await self.retryer(self._down,url,headers)
+            return data ,b
+
+    async def _key_down_with_retry(self, url : str, segment : Optional[models.Segment], headers : dict =None):
+            try:
+                return await self.retryer(self.key_down,url,headers)
+            except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                FailedKey=models.FailedKey(
+                    segment=segment, reason='Down Failed',
+                    attempts=self.attempts, exception=e)
+                
+                self.FailedKey.append(FailedKey)
+                return None
+        
+    async def Writefile(self, data : Any  ,file_path : str | Path):
+        async with aiofiles.open(file_path ,'w+b') as f:
+            await f.write(data)
+
+    async def async_Writefile(self, file_path : str | Path, response : aiohttp.client_reqrep.ClientResponse):
+        async with aiofiles.open(file_path ,'w+b') as f:
+            async for chunk in response.content.iter_chunked(1024):
+                await f.write(chunk)
+
+    async def give_DECODE(self, data : bytes, segment : Optional[models.Segment])->bytes:
+        ok_data =None
+        if segment.key and segment.key.key_uri:
+            key_uri=segment.key.key_uri
+        else:
+            raise exceptions.KEYisNoneError(reason='No Have Key URI')    #解密
+        if self.defined_key.defined_func:
+                if self.defined_key.defined_func.get(key_uri,None):
+                    ok= self.defined_key.defined_func[key_uri](data, self.defined_key.defined_key.get(key_uri), self.defined_key.defined_iv.get(key_uri))
+                    if asyncio.iscoroutine(ok):
+                        ok = await ok
+                    ok_data = ok
+        elif self.defined_key.defined_key.get(key_uri,None):    #提前设置好的key
+            ok_data = await self.DECODE(data=data, key=self.defined_key.defined_key.get(key_uri), iv=self.defined_key.defined_iv.get(key_uri,None), method=self.defined_key.defined_method, seq=segment.num,key_uri=key_uri)
+        else: 
+            ok_data = await self.DECODE(data, self.key_dic.get(key_uri), segment.key.iv, segment.key.method, segment.num,key_uri=key_uri)
+        return ok_data
+    
+    async def DECODE(self, data, key, iv, method, seq : int,key_uri:str)->bytes:
+        if key is None:
+            raise exceptions.KEYisNoneError( reason='Key Not Cached')
+        if iv is None and seq is None:
+            raise exceptions.FailedDecodeSegmentError('see FailedSegment', reason='IV Missing')
+        if method :
+                if method==models.EncryptMethod.AES_128:
+                    if iv is None and seq is not None:
+                         iv=seq.to_bytes(16, byteorder='big')
+                    if len(key)==16 and len(iv)==16:
+                        cipher = AES.new(key, AES.MODE_CBC,iv)
+                        try:
+                            return unpad(cipher.decrypt(data), 16)
+                        except ValueError as e:raise exceptions.FailedDecodeSegmentError(key_uri, reason=f'bad padding: {e}') from e
+                    else:raise ValueError('Key Or iv len no 16 bytes')
+                else:
+                     raise exceptions.FailedDecodeSegmentError('see FailedSegment',reason='Decoding Failed')
+        else:
+            raise exceptions.FailedNoMethodError()
+
+    async def Add_KEY(self, segment : Optional[models.Segment])->bool:
+        async with self.lock:
+            if segment.key and segment.key.key_uri:
+                key_uri=segment.key.key_uri
+                if key_uri not in self.key_dic and not self.defined_key.defined_key.get(key_uri,None):
+                    key_data=await self._key_down_with_retry(url=key_uri.strip('\"\''), segment=segment, headers=self.headers)
+                    if key_data is not None and len(key_data) == 16:
+                        self.key_dic[key_uri]=key_data
+                        if self.defined_key.encrypto_key.get(key_uri,None):#如有解密方式就解密key(要先有key的内容)
+                            ok=self.defined_key.encrypto_key[key_uri](self.key_dic[key_uri])
+                            if asyncio.iscoroutine(ok):
+                                ok = await ok
+                            self.key_dic[key_uri] = ok
+            return True
+            
+    async def Add_MAP(self, filepath, segment : models.Segment)->bool:
+        map_data=None
+        map_uri=segment.map_uri
+        if map_uri and map_uri not in self.map_list:
+            file_name = map_uri.rsplit('/',1)[1].rsplit('?',1)[0]
+            segment_tmp=[models.MapSegment(after_uri=segment,num=segment.num),file_name]
+            if self.config.Wait_Merge:
+                self._segment_list.append(segment_tmp)
+
+            map_data,b= await self._down_with_retry(url=map_uri.lstrip('\"\''),headers=self.headers)
+
+               #解密
+            if b:
+                if segment.key and segment.key.key_uri:
+                    map_data=await self.give_DECODE(data=map_data, segment=segment)
+                await self.Writefile(map_data, str(filepath / file_name))
+            if segment_tmp not in self._segment_list:
+                self._segment_list.append(segment_tmp)
+                self.map_list.append(map_uri)
+            #self._down_with_retry已经抛过并添加金FailedSegment里了不用判断b
+            else:
+                return False
+        return True
+        
+    async def DownAndDecode(self, segment :Optional[models.Segment], file_path : Optional[Path],progress : Progress=None)->bool:  #只负责将切片(密钥由Add_KEY负责)下载和解密和写入，其他都不负责
+        _uri =segment.uri        #正常切片url
+        file_name = _uri.rsplit('/',1)[1].rsplit('?',1)[0]
+        segment_tmp=[segment, file_name]
+        if self.config.Wait_Merge:
+            self._segment_list.append(segment_tmp)
+
+        ok_data, b= await self._down_with_retry(_uri, headers=self.headers)      #下载
+       
+        if b:   #是否正常获取
+            if segment.key and segment.key.key_uri:
+                ok_data=await self.give_DECODE(data=ok_data,segment=segment)
+            _file_path = str(file_path / file_name )    #写入
+            await self.Writefile(ok_data, _file_path)
+            progress.update(self.task, advance=1)
+            if segment_tmp not in self._segment_list:
+                self._segment_list.append(segment_tmp)
+        else:
+            raise exceptions.Down_BadError(url=segment.uri)
+        return True
+        
+    async def downner(self)->dict:
+        progress=self.progress
+        _file_path=self.path / 'ts_file' / self.outname
+        _file_path.mkdir(parents=True,exist_ok=True)
+        async def task(segment):
+            async with self.semaphore:
+                try:
+                    if segment.key:
+                        await self.Add_KEY(segment)     #记录key
+                    await self.Add_MAP(segment=segment, filepath=_file_path)
+                    await self.DownAndDecode(segment, _file_path,progress=progress)
+                except exceptions.FailedNoMethodError as e:
+                    self.Bad_key.append(models.KeyErrorInfo(segment=segment,reason=exceptions.FailedNoMethodError(),exception=str(e)))
+
+                except exceptions.FailedMethodError as e:
+                    self.Bad_key.append(models.KeyErrorInfo(segment=segment,reason='The encryption type is not supported right now',exception=str(e)))
+
+                except exceptions.FailedDecodeSegmentError as e:
+                    self.Bad_key.append(models.KeyErrorInfo(segment=segment,reason='Decoding Bad',exception=str(e)))
+
+                except exceptions.KEYisNoneError as e:
+                    self.FailedSegments.append(models.FailedSegment(segment=segment,reason='Key is None',attempts=self.attempts,exception=str(e)))
+
+                except exceptions.Down_BadError as e:
+                      self.Bad_key.append(models.FailedSegment(segment=segment,reason='Bad URI',attempts=self.attempts,exception=str(e)))
+
+                except exceptions.FailedSegmentError as e:
+                    self.FailedSegments.append(models.FailedSegment(segment=segment,reason='Down or Decode FailedSegmentError',attempts=self.attempts,exception=str(e)))
+
+                except (aiohttp.ClientError, asyncio.TimeoutError) as e:
+                    self.FailedSegments.append(models.FailedSegment(segment=segment, reason='Down Failed',attempts=self.attempts, exception=str(e)))
+
+                except Exception as e:
+                    self.logger.exception(e)
+                    self.FailedSegments.append(models.FailedSegment(segment=segment, reason='Down Failed',attempts=self.attempts, exception=str(e)))
+                
+        #记录key和下载解密
+
+        await asyncio.gather(*[task(segment) for segment in self.segment_lists])
+        self.ts_list=  [fn for seg, fn in sorted(self._segment_list,key=lambda x: (x[0].num, 0 if isinstance(x[0], models.MapSegment) else 1))]
+        LIST_PATH = str(_file_path / f'{self.outname}_list.txt')
+        async with aiofiles.open(LIST_PATH, 'w', encoding='utf-8') as f:
+            for i in self.ts_list:
+                a=f'file {i}\n'
+                await f.write(a)      
+        return {'failed_key':self.FailedKey,
+                'failed_segments':self.FailedSegments,
+                'key_Error':self.Bad_key,
+                'segments_total':len(self.segment_lists),
+                'OutputPath':_file_path,
+                'list_path':LIST_PATH,
+                'key_dic':self.key_dic,
+                'map_list':self.map_list,
+                'semaphore':self.config.concurrency,
+                'time':time.time()-self.start_time
+                    }

phlsm3u8_downner-0.1.0/phlsM3U8_downner/_Converter.py

@@ -0,0 +1,59 @@
+from dataclasses import dataclass
+from pathlib import Path
+import ffmpeg,asyncio,logging
+from . import exceptions
+
+"""这个是用来合并文件的"""
+@dataclass
+class converter:
+    def __post_init__(self):
+        self.logger = logging.getLogger(__name__)
+    LIST_TXT_PATH : str
+    OUT_NAME : str
+    quiet : bool =False
+    keep_segments : bool =False #是否清理分片默认否
+    async def converter(self):
+        self.logger.debug('Get ready Converter -> %s',self.OUT_NAME)
+        self.list_path = Path(self.LIST_TXT_PATH)
+        self.out_path=self.list_path.parent / self.OUT_NAME
+        self._list_path=self.list_path.read_text()[5:]
+        try:
+            stream = (
+                    ffmpeg.input(str(self.list_path), format='concat', safe=0)
+                        .output(str(self.out_path), c='copy').global_args('-nostdin', '-nostats', '-hide_banner', '-loglevel', 'error')
+                        )
+                
+            self.logger.info('Start Converter -> %s',self.OUT_NAME)
+            self.logger.debug('ffpeg Order: %s',' '.join(stream.compile()))
+            process = stream.run_async(
+                pipe_stdin=True, pipe_stdout=True, pipe_stderr=True,
+                overwrite_output=True,          # 无条件 -y
+            )
+            _, stderr = await asyncio.to_thread(process.communicate)
+
+            if process.returncode != 0:
+                raise exceptions.FailedConverterError(
+                    out_path=str(self.out_path),
+                    reason=(stderr or b'').decode('utf-8', 'ignore') or 'no stderr captured',
+                )
+
+            delete_list = [
+            line.strip().split(' ', 1)[1].strip().strip('\'"')
+            for line in self.list_path.read_text(encoding='utf-8').splitlines()
+            if line.strip()
+            ]
+            self.logger.info('Converter Success %s Start delete [ts/m4s/mp4...]file',self.OUT_NAME)
+            if not self.keep_segments:
+                parent = self.list_path.parent
+                for f in delete_list:
+                    (parent / f).unlink(missing_ok=True)
+                self.list_path.unlink()
+            self.logger.info('Converter Success %s',self.OUT_NAME)
+
+            return (self.out_path.stat().st_size)
+        except ffmpeg.Error as e:
+            self.logger.error('ffmpeg: %s', e)
+            raise exceptions.FailedConverterError(str(self.out_path),(e.stderr.decode('utf-8', 'ignore') if getattr(e, 'stderr', None) else str(e)))
+
+        # finally:
+