230 lines
8.6 KiB
Python
Executable File
230 lines
8.6 KiB
Python
Executable File
#!/usr/bin/env python3
|
||
# vim: tabstop=8 expandtab shiftwidth=4 softtabstop=4
|
||
|
||
"""
|
||
radiorec.py – Recording internet radio streams
|
||
Copyright (C) 2013 Martin Brodbeck <martin@brodbeck-online.de>
|
||
|
||
This program is free software: you can redistribute it and/or modify
|
||
it under the terms of the GNU General Public License as published by
|
||
the Free Software Foundation, either version 3 of the License, or
|
||
(at your option) any later version.
|
||
|
||
This program is distributed in the hope that it will be useful,
|
||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||
GNU General Public License for more details.
|
||
|
||
You should have received a copy of the GNU General Public License
|
||
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||
"""
|
||
|
||
import argparse
|
||
import configparser
|
||
import datetime
|
||
import os
|
||
import stat
|
||
import sys
|
||
import threading
|
||
import urllib3
|
||
import logging
|
||
import time
|
||
from urllib3.exceptions import MaxRetryError
|
||
logging.basicConfig(level=logging.DEBUG)
|
||
|
||
|
||
def print_time():
|
||
return time.strftime("%Y-%m-%d %H:%M:%S")
|
||
|
||
|
||
def check_duration(value):
|
||
try:
|
||
value = int(value)
|
||
except ValueError:
|
||
raise argparse.ArgumentTypeError(
|
||
'Duration in minutes must be a positive integer.')
|
||
|
||
if value < 1:
|
||
raise argparse.ArgumentTypeError(
|
||
'Duration in minutes must be a positive integer.')
|
||
else:
|
||
return value
|
||
|
||
|
||
def read_settings(args):
|
||
settings_base_dir = ''
|
||
if args.settings:
|
||
settings_base_dir = args.settings
|
||
elif sys.platform.startswith('linux'):
|
||
settings_base_dir = os.getenv(
|
||
'HOME') + os.sep + '.config' + os.sep + 'radiorec'
|
||
elif sys.platform == 'win32':
|
||
settings_base_dir = os.getenv('LOCALAPPDATA') + os.sep + 'radiorec'
|
||
elif sys.platform == 'darwin':
|
||
settings_base_dir = os.getenv('HOME') + os.sep + 'Library' + os.sep + \
|
||
'Application Support' + os.sep + 'radiorec'
|
||
settings_base_dir += os.sep
|
||
config = configparser.ConfigParser()
|
||
try:
|
||
config.read_file(open(settings_base_dir + 'settings.ini'))
|
||
except FileNotFoundError as err:
|
||
print(str(err))
|
||
print('Please copy/create the settings file to/in the appropriate location.')
|
||
sys.exit()
|
||
return dict(config.items())
|
||
|
||
|
||
def record_worker(stoprec, streamurl, target_dir, args):
|
||
pool = urllib3.PoolManager()
|
||
conn = pool.request('GET', streamurl, preload_content=False)
|
||
conn.auto_close = False
|
||
if conn.status != 200:
|
||
conn.release_conn()
|
||
time.sleep(10)
|
||
verboseprint(print_time() + " ... Waited to return for retry bcof status " + str(conn.status))
|
||
return
|
||
|
||
cur_dt_string = datetime.datetime.now().strftime('%Y-%m-%dT%H_%M_%S')
|
||
filename = target_dir + os.sep + cur_dt_string + "_" + args.station
|
||
if args.name:
|
||
filename += '_' + args.name
|
||
content_type = conn.getheader('Content-Type')
|
||
if (content_type == 'audio/mpeg'):
|
||
filename += '.mp3'
|
||
elif(content_type == 'application/aacp' or content_type == 'audio/aacp'):
|
||
filename += '.aac'
|
||
elif(content_type == 'application/ogg' or content_type == 'audio/ogg'):
|
||
filename += '.ogg'
|
||
elif(content_type == 'audio/x-mpegurl'):
|
||
print('Sorry, M3U playlists are currently not supported')
|
||
sys.exit()
|
||
else:
|
||
print('Unknown content type "' + content_type + '". Assuming mp3.')
|
||
filename += '.mp3'
|
||
|
||
verboseprint(print_time() + " ... Writing to: " + filename + ", Content-Type: " + conn.getheader('Content-Type'))
|
||
with open(filename, 'wb') as target:
|
||
if args.public:
|
||
verboseprint('Apply public write permissions (Linux only)')
|
||
os.chmod(filename, stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IWGRP | stat.S_IROTH | stat.S_IWOTH)
|
||
while(not stoprec.is_set() and not conn.closed):
|
||
target.write(conn.read(1024))
|
||
|
||
verboseprint(print_time() + " ... Connection closed = " + str(conn.closed))
|
||
conn.release_conn()
|
||
|
||
|
||
def record(args):
|
||
settings = read_settings(args)
|
||
streamurl = ''
|
||
tmpstr = ''
|
||
global verboseprint
|
||
verboseprint = print if args.verbose else lambda *a, **k: None
|
||
|
||
try:
|
||
streamurl = settings['STATIONS'][args.station]
|
||
except KeyError:
|
||
print('Unkown station name: ' + args.station)
|
||
sys.exit()
|
||
if streamurl.endswith('.m3u'):
|
||
verboseprint('Seems to be an M3U playlist. Trying to parse...')
|
||
pool = urllib3.PoolManager()
|
||
try:
|
||
remotefile = pool.request('GET', streamurl)
|
||
except MaxRetryError:
|
||
logging.getLogger(__name__).error('The URL of the station is somehow faulty! Check' +
|
||
args.station + ' in the Settings!')
|
||
sys.exit()
|
||
if remotefile.status != 200:
|
||
logging.getLogger(__name__).error(
|
||
'The URL of the station is somehow faulty! Check' + args.station + ' in the Settings!')
|
||
sys.exit(1)
|
||
else:
|
||
for line in remotefile.data.decode().split():
|
||
if not line.startswith('#') and len(line) > 1 and line.endswith('mp3'):
|
||
tmpstr = line
|
||
break
|
||
if not tmpstr:
|
||
logging.getLogger(__name__).error('Could not find a mp3 stream')
|
||
sys.exit(1)
|
||
else:
|
||
streamurl = tmpstr
|
||
|
||
verboseprint(print_time() + " ... Stream URL: " + streamurl)
|
||
target_dir = os.path.expandvars(settings['GLOBAL']['target_dir'])
|
||
if not os.path.isdir(target_dir):
|
||
try:
|
||
os.mkdir(target_dir)
|
||
except FileNotFoundError:
|
||
logging.getLogger(__name__).error('Target directory not found! Check that ' +
|
||
target_dir + ' is a valid folder!')
|
||
sys.exit(1)
|
||
started_at = time.time()
|
||
should_end_at = started_at + (args.duration * 60)
|
||
remaining = (args.duration * 60)
|
||
|
||
# as long as recording is supposed to run
|
||
while time.time() < should_end_at:
|
||
stoprec = threading.Event()
|
||
recthread = threading.Thread(target=record_worker, args=(stoprec, streamurl, target_dir, args))
|
||
recthread.setDaemon(True)
|
||
recthread.start()
|
||
verboseprint(print_time() + " ... Started thread " + str(recthread) + " timeout: " +
|
||
str(remaining / 60) + " min")
|
||
recthread.join(remaining)
|
||
verboseprint(print_time() + " ... Came out of rec thread again")
|
||
|
||
if recthread.is_alive:
|
||
stoprec.set()
|
||
verboseprint(print_time() + " ... Called stoprec.set()")
|
||
else:
|
||
verboseprint(print_time() + " ... recthread.is_alive = False")
|
||
|
||
remaining = should_end_at - time.time()
|
||
verboseprint(print_time() + " ... Remaining: " + str(remaining / 60) +
|
||
", Threads: " + str(threading.activeCount()))
|
||
|
||
|
||
def list(args):
|
||
settings = read_settings(args)
|
||
for key in sorted(settings['STATIONS']):
|
||
print(key)
|
||
|
||
|
||
def main():
|
||
parser = argparse.ArgumentParser(description='This program records internet radio streams. '
|
||
'It is free software and comes with ABSOLUTELY NO WARRANTY.')
|
||
subparsers = parser.add_subparsers(help='sub-command help')
|
||
parser_record = subparsers.add_parser('record', help='Record a station')
|
||
parser_record.add_argument('station', type=str,
|
||
help='Name of the radio station '
|
||
'(see `radiorec.py list`)')
|
||
parser_record.add_argument('duration', type=check_duration,
|
||
help='Recording time in minutes')
|
||
parser_record.add_argument('name', nargs='?', type=str,
|
||
help='A name for the recording')
|
||
parser_record.add_argument(
|
||
'-p', '--public', action='store_true',
|
||
help="Public write permissions (Linux only)")
|
||
parser_record.add_argument(
|
||
'-v', '--verbose', action='store_true', help="Verbose output")
|
||
parser_record.add_argument(
|
||
'-s', '--settings', nargs='?', type=str,
|
||
help="specify alternative location for settings.ini")
|
||
parser_record.set_defaults(func=record)
|
||
parser_list = subparsers.add_parser('list', help='List all known stations')
|
||
parser_list.set_defaults(func=list)
|
||
parser_list.add_argument('-s', '--settings', nargs='?', type=str,
|
||
help="specify alternative location for settings.ini")
|
||
|
||
if not len(sys.argv) > 1:
|
||
print('Error: No argument specified.\n')
|
||
parser.print_help()
|
||
sys.exit(1)
|
||
args = parser.parse_args()
|
||
args.func(args)
|
||
|
||
|
||
if __name__ == '__main__':
|
||
main()
|