import os import sys import time import requests import subprocess import gzip import io from datetime import datetime, timedelta,timezone from PyQt5.QtWidgets import ( QApplication, QMainWindow, QVBoxLayout, QListWidget, QWidget, QHBoxLayout, QListWidgetItem, QLabel, QSplitter, QFrame, QPushButton, QSlider, QSizePolicy, QScrollArea,QGridLayout ) from PyQt5.QtCore import Qt, QTimer, QEvent, QTime, QUrl, QThread, pyqtSignal from PyQt5.QtGui import QFont import pytz import vlc import xml.etree.ElementTree as ET class VideoFrame(QFrame): def __init__(self, parent=None): super().__init__(parent) self.setStyleSheet("background-color: black;") class VLCPlayer: def __init__(self, video_frame): self.instance = vlc.Instance() self.media_player = self.instance.media_player_new() if sys.platform == "win32": self.media_player.set_hwnd(int(video_frame.winId())) else: self.media_player.set_xwindow(int(video_frame.winId())) def play_stream(self, url): media = self.instance.media_new(url) media.add_option(":network-caching=1000") self.media_player.set_media(media) self.media_player.play() self.media_player.audio_set_volume(70) def stop(self): self.media_player.stop() def release(self): self.media_player.release() self.instance.release() class EPGDownloader(QThread): epg_downloaded = pyqtSignal(bytes) error_occurred = pyqtSignal(str) def __init__(self, epg_url): super().__init__() self.epg_url = epg_url def run(self): try: response = requests.get(self.epg_url, timeout=10) response.raise_for_status() self.epg_downloaded.emit(response.content) except Exception as e: self.error_occurred.emit(f"EPG download failed: {str(e)}") class IPTVWindow(QMainWindow): def __init__(self, php_dir): super().__init__() self.setWindowTitle("IPTV Player with EPG") self.setGeometry(100, 100, 1280, 720) self.php_dir = php_dir self._is_fullscreen = False self._normal_geometry = None self._normal_flags = None self.current_channel_epg = None self.epg_url = None self.epg_data = None self.epg_last_update = None self.debug_log = [] self.epg_grid_window = None # ← Add this line self.init_ui() self.installEventFilter(self) self.download_playlist() def log_debug(self, message): """Add debug message to log and print to console""" timestamp = datetime.now().strftime("%H:%M:%S") full_message = f"[{timestamp}] {message}" self.debug_log.append(full_message) print(full_message) if hasattr(self, 'debug_display'): self.debug_display.addItem(full_message) self.debug_display.scrollToBottom() def init_ui(self): self.splitter = QSplitter(Qt.Horizontal) # Left panel with channels self.channel_list = QListWidget() self.channel_list.itemClicked.connect(self.on_channel_clicked) self.splitter.addWidget(self.channel_list) # Right panel with video and EPG right_panel = QWidget() layout = QVBoxLayout(right_panel) layout.setContentsMargins(0, 0, 0, 0) layout.setSpacing(0) self.video_container = QWidget() self.video_container.setStyleSheet("background-color: black;") self.video_container.setMinimumHeight(400) video_container_layout = QVBoxLayout(self.video_container) video_container_layout.setContentsMargins(0, 0, 0, 0) self.video_frame = VideoFrame(self.video_container) self.video_frame.mouseDoubleClickEvent = self.toggle_fullscreen video_container_layout.addWidget(self.video_frame) layout.addWidget(self.video_container, stretch=3) self.player = VLCPlayer(self.video_frame) # EPG Display with new formatting self.epg_display = QLabel() self.epg_display.setStyleSheet(""" background-color: #222; color: white; padding: 10px; """) self.epg_display.setWordWrap(True) self.epg_display.setAlignment(Qt.AlignTop | Qt.AlignLeft) layout.addWidget(self.epg_display, stretch=1) # Timers self.clock_timer = QTimer() self.clock_timer.timeout.connect(self.refresh_epg_time) self.clock_timer.start(1000) self.epg_update_timer = QTimer() self.epg_update_timer.timeout.connect(self.update_epg_data) self.epg_update_timer.start(3600000) # Update EPG every hour # Controls self.controls = QWidget() ctl_layout = QHBoxLayout(self.controls) for text, slot in [("⏮️", self.play_previous_channel), ("⏯️", self.toggle_play_pause), ("⏭️", self.play_next_channel), ("🖵", self.toggle_fullscreen), ("📅", self.toggle_epg_grid), ("🔄", self.update_epg_data)]: btn = QPushButton(text) btn.clicked.connect(slot) ctl_layout.addWidget(btn) self.volume_slider = QSlider(Qt.Horizontal) self.volume_slider.setRange(0, 200) self.volume_slider.setValue(70) self.volume_slider.setToolTip("Volume") self.volume_slider.valueChanged.connect(self.set_volume) ctl_layout.addWidget(self.volume_slider) self.mute_button = QPushButton("🔊") self.mute_button.setCheckable(True) self.mute_button.clicked.connect(self.toggle_mute) ctl_layout.addWidget(self.mute_button) layout.addWidget(self.controls) self.splitter.addWidget(right_panel) self.splitter.setSizes([300, 980]) self.setCentralWidget(self.splitter) def set_volume(self, value): self.player.media_player.audio_set_volume(value) if value == 0: self.player.media_player.audio_set_mute(True) self.mute_button.setChecked(True) self.mute_button.setText("🔇") else: self.player.media_player.audio_set_mute(False) self.mute_button.setChecked(False) self.mute_button.setText("🔊") def toggle_mute(self): is_muted = self.player.media_player.audio_get_mute() self.player.media_player.audio_set_mute(not is_muted) self.mute_button.setText("🔇" if not is_muted else "🔊") self.mute_button.setChecked(not is_muted) def update_epg_info(self, name, resolution): if not hasattr(self, 'current_channel_name'): return # Create formatted EPG text epg_text = "" # Channel name (top left) and resolution (top right) channel_font = QFont() channel_font.setPointSize(14) channel_font.setBold(True) epg_text += "" epg_text += f"" epg_text += "
{name}{resolution}
" # Current program if self.current_channel_epg: # Title (big and bold) epg_text += f"
" epg_text += f"{self.current_channel_epg.get('title', 'No Programme Information')}" epg_text += "
" # Time and duration if 'start' in self.current_channel_epg and 'stop' in self.current_channel_epg: start = self.current_channel_epg['start'] stop = self.current_channel_epg['stop'] try: # Convert GMT times to aware datetime objects gmt_start = datetime.strptime(start[:14], "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc) gmt_stop = datetime.strptime(stop[:14], "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc) # Convert to local time (Pakistan time here, change if needed) local_tz = pytz.timezone("Asia/Karachi") start_local = gmt_start.astimezone(local_tz) stop_local = gmt_stop.astimezone(local_tz) now_local = datetime.now(local_tz) # Format time display start_time_str = start_local.strftime("%I:%M%p").lstrip('0') stop_time_str = stop_local.strftime("%I:%M%p").lstrip('0') duration = int((stop_local - start_local).total_seconds() // 60) # Progress percentage total_seconds = (stop_local - start_local).total_seconds() elapsed_seconds = (now_local - start_local).total_seconds() progress_percent = max(0, min(100, int((elapsed_seconds / total_seconds) * 100))) if total_seconds > 0 else 0 # Build HTML progress bar progress_bar_html = f"""
""" # Add everything to epg_text epg_text += f"
" epg_text += f"{start_time_str} - {stop_time_str} ({duration} mins)" epg_text += progress_bar_html epg_text += "
" except: pass # Description if 'desc' in self.current_channel_epg and self.current_channel_epg['desc']: epg_text += f"
" epg_text += f"{self.current_channel_epg['desc']}" epg_text += "
" # Next program if self.next_program_epg: epg_text += f"
" epg_text += f"Next: {self.next_program_epg.get('title', 'No information')}" epg_text += "
" if 'start' in self.next_program_epg and 'stop' in self.next_program_epg: start = self.next_program_epg['start'] stop = self.next_program_epg['stop'] try: # Convert GMT times to aware datetime objects gmt_start = datetime.strptime(start[:14], "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc) gmt_stop = datetime.strptime(stop[:14], "%Y%m%d%H%M%S").replace(tzinfo=timezone.utc) # Convert to local time (Pakistan time here, change if needed) local_tz = pytz.timezone("Asia/Karachi") start_local = gmt_start.astimezone(local_tz) stop_local = gmt_stop.astimezone(local_tz) # Format time display start_time_str = start_local.strftime("%I:%M%p").lstrip('0') stop_time_str = stop_local.strftime("%I:%M%p").lstrip('0') epg_text += f"
" epg_text += f"{start_time_str} - {stop_time_str}" epg_text += "
" except: pass else: epg_text += "
" epg_text += "No Programme Information" epg_text += "
" self.epg_display.setText(epg_text) def update_current_epg(self): if not self.epg_data or not hasattr(self, 'current_channel_id'): return try: # Get current LOCAL time now_local = datetime.now() # Convert to equivalent GMT time string for matching with EPG (which is in GMT) now_gmt = now_local.astimezone(pytz.utc) current_time = now_gmt.strftime("%Y%m%d%H%M%S") found_current = False found_next = False for programme in self.epg_data.findall('.//programme'): channel_id = programme.get('channel') if channel_id != self.current_channel_id: continue start = programme.get('start') stop = programme.get('stop') if not found_current and start <= current_time <= stop: # Current program self.current_channel_epg = { 'title': programme.find('title').text if programme.find('title') is not None else 'No Programme Information', 'start': start, 'stop': stop, 'desc': programme.find('desc').text if programme.find('desc') is not None else '' } found_current = True elif found_current and not found_next and start > current_time: # Next program self.next_program_epg = { 'title': programme.find('title').text if programme.find('title') is not None else 'No information', 'start': start, 'stop': stop } found_next = True break if not found_current: self.current_channel_epg = None self.next_program_epg = None elif not found_next: self.next_program_epg = None # Update the display if hasattr(self, 'current_channel_name') and hasattr(self, 'current_channel_resolution'): self.update_epg_info(self.current_channel_name, self.current_channel_resolution) except Exception as e: print(f"Error updating current EPG: {str(e)}") def refresh_epg_time(self): if not hasattr(self, 'current_channel_name') or not hasattr(self, 'current_channel_resolution'): return text = self.epg_display.text() parts = text.split("\n", 1) if len(parts) == 2: first_line, epg_line = parts if "|" in first_line: name_resolution = first_line.split("|") if len(name_resolution) >= 2: name = name_resolution[0].replace("", "").replace("", "").strip() resolution = name_resolution[1].strip() self.update_epg_info(name, resolution, self.current_channel_epg) def update_epg_data(self): if not self.epg_url: self.log_debug("No EPG URL available") return self.log_debug(f"Downloading EPG data from: {self.epg_url}") self.epg_downloader = EPGDownloader(self.epg_url) self.epg_downloader.epg_downloaded.connect(self.process_epg_data) self.epg_downloader.error_occurred.connect(self.log_debug) self.epg_downloader.start() def process_epg_data(self, epg_bytes): try: # Try to decompress the data try: epg_xml = gzip.decompress(epg_bytes).decode('utf-8') self.log_debug("EPG data decompressed successfully") except: epg_xml = epg_bytes.decode('utf-8') self.log_debug("EPG data was not compressed") # Save the raw XML for debugging debug_epg_path = os.path.join(self.php_dir, "last_epg.xml") with open(debug_epg_path, "w", encoding="utf-8") as f: f.write(epg_xml) self.log_debug(f"Saved EPG data to {debug_epg_path}") # Parse the XML self.epg_data = ET.fromstring(epg_xml) self.epg_last_update = datetime.now() self.log_debug(f"EPG data parsed successfully, last update: {self.epg_last_update}") # Update current channel's EPG if available if hasattr(self, 'current_channel_id'): self.update_current_epg() except Exception as e: self.log_debug(f"Error processing EPG data: {str(e)}") def toggle_epg_grid(self): if not self.epg_data: self.log_debug("EPG data not loaded yet.") return if self.epg_grid_window is None: self.epg_grid_window = EPGGridWindow(self.epg_data) if self.epg_grid_window.isVisible(): self.epg_grid_window.hide() else: self.epg_grid_window.show() def detect_resolution(self, item, base): w = self.player.media_player.video_get_width() h = self.player.media_player.video_get_height() fps = self.player.media_player.get_fps() if w > 0 and h > 0: label = "SD" if w >= 3840: label = "4K" elif w >= 1920: label = "FHD" elif w >= 1280: label = "HD" info = f"{label}-{fps:.2f} FPS" item.setText(f"{base} ({info})") self.current_channel_name = base self.current_channel_resolution = info self.update_epg_info(base, info) def on_channel_clicked(self, item: QListWidgetItem): url = item.data(Qt.UserRole) self.player.play_stream(url) # Get channel ID from item data channel_id = item.data(Qt.UserRole + 1) if channel_id: self.current_channel_id = channel_id self.update_current_epg() base = item.text().split('(')[0].strip() item.setText(f"{base} (Loading...)") self.current_channel_name = base self.update_epg_info(base, "Loading...") QTimer.singleShot(4000, lambda: self.detect_resolution(item, base)) def toggle_play_pause(self): mp = self.player.media_player if mp.is_playing(): mp.pause() else: mp.play() def play_next_channel(self): idx = self.channel_list.currentRow() if idx < self.channel_list.count() - 1: self.channel_list.setCurrentRow(idx+1) self.on_channel_clicked(self.channel_list.currentItem()) def play_previous_channel(self): idx = self.channel_list.currentRow() if idx > 0: self.channel_list.setCurrentRow(idx-1) self.on_channel_clicked(self.channel_list.currentItem()) def toggle_fullscreen(self, event=None): if not self._is_fullscreen: self._normal_geometry = self.geometry() self._normal_flags = self.windowFlags() self.channel_list.hide() self.epg_display.hide() self.controls.hide() self.setWindowFlags(self._normal_flags | Qt.FramelessWindowHint) self.showFullScreen() else: self.setWindowFlags(self._normal_flags) self.showNormal() if self._normal_geometry: self.setGeometry(self._normal_geometry) self.channel_list.show() self.epg_display.show() self.controls.show() self._is_fullscreen = not self._is_fullscreen def keyPressEvent(self, event): if event.key() == Qt.Key_Escape and self._is_fullscreen: self.toggle_fullscreen() else: super().keyPressEvent(event) def download_playlist(self): try: os.makedirs(self.php_dir, exist_ok=True) url = "https://iptv.nywebforum.com/playlist.m3u" self.log_debug(f"Downloading playlist from: {url}") response = requests.get(url, timeout=10) content = response.text.replace( "https://iptv.nywebforum.com", "http://localhost:8888" ) # Extract EPG URL from the first line if present first_line = response.text.split('\n')[0] if first_line.startswith("#EXTM3U") and "url-tvg=" in first_line: self.epg_url = first_line.split('url-tvg="')[1].split('"')[0] self.log_debug(f"Found EPG URL: {self.epg_url}") self.update_epg_data() # Download EPG immediately path = os.path.join(self.php_dir, "playlist.m3u") with open(path, "w", encoding="utf-8") as f: f.write(content) self.log_debug(f"Playlist saved to: {path}") self.load_playlist(path) except Exception as e: self.log_debug(f"Failed to download playlist: {e}") def load_playlist(self, path): try: self.log_debug(f"Loading playlist from: {path}") lines = open(path, encoding="utf-8").read().splitlines() self.channel_list.clear() first = None name = None channel_id = None for i, l in enumerate(lines): if l.startswith("#EXTINF:"): # Extract channel name name = l.split(',')[-1].strip() # Extract channel ID if present (tvg-id attribute) if 'tvg-id="' in l: channel_id = l.split('tvg-id="')[1].split('"')[0] self.log_debug(f"Found channel ID: {channel_id} for {name}") elif l and not l.startswith("#") and name: it = QListWidgetItem(f"{name} (Loading...)") it.setData(Qt.UserRole, l) # Store channel ID with the item if available if channel_id: it.setData(Qt.UserRole + 1, channel_id) self.channel_list.addItem(it) if first is None: first = it name = None channel_id = None if first: self.channel_list.setCurrentItem(first) self.log_debug(f"Found {self.channel_list.count()} channels, selecting first one") QTimer.singleShot(1000, lambda: self.on_channel_clicked(first)) except Exception as e: self.log_debug(f"Failed to load playlist: {e}") def closeEvent(self, event): self.log_debug("Application closing - cleaning up resources") # Stop timers self.clock_timer.stop() self.epg_update_timer.stop() # Stop player self.player.stop() self.player.release() # Stop any ongoing EPG download if hasattr(self, 'epg_downloader') and self.epg_downloader.isRunning(): self.epg_downloader.quit() self.epg_downloader.wait() super().closeEvent(event) class EPGGridWindow(QMainWindow): def __init__(self, epg_data): super().__init__() self.setWindowTitle("Full EPG") self.resize(1400, 800) self.setStyleSheet("background-color: #222; color: white; font-size: 10pt;") self.epg_data = epg_data self.channel_ids = sorted({prog.get("channel") for prog in epg_data.findall(".//programme")}) # === Main layout === main_widget = QWidget() main_layout = QVBoxLayout(main_widget) main_layout.setContentsMargins(0, 0, 0, 0) # === Top bar with close button === top_bar = QHBoxLayout() close_btn = QPushButton("❌ Close EPG") close_btn.setStyleSheet("font-size: 14px; background-color: red; color: white; padding: 5px;") close_btn.clicked.connect(self.close) top_bar.addStretch() top_bar.addWidget(close_btn) main_layout.addLayout(top_bar) # === Content layout === content_layout = QHBoxLayout() # --- Left: Channel names (fixed column) --- self.channel_scroll = QScrollArea() self.channel_scroll.setWidgetResizable(True) self.channel_widget = QWidget() self.channel_layout = QVBoxLayout(self.channel_widget) self.channel_layout.setSpacing(1) self.channel_layout.setContentsMargins(0, 0, 0, 0) for i, ch_id in enumerate(self.channel_ids): label = QLabel(ch_id) label.setStyleSheet(f"background-color: {'#333' if i%2 else '#444'}; padding: 6px;") self.channel_layout.addWidget(label) self.channel_scroll.setWidget(self.channel_widget) self.channel_scroll.setFixedWidth(200) content_layout.addWidget(self.channel_scroll) # --- Right: EPG Grid --- self.epg_scroll = QScrollArea() self.epg_scroll.setWidgetResizable(True) self.epg_grid_widget = QWidget() self.epg_layout = QGridLayout(self.epg_grid_widget) self.epg_layout.setSpacing(1) self.epg_layout.setContentsMargins(0, 0, 0, 0) self.build_epg_grid() self.epg_scroll.setWidget(self.epg_grid_widget) content_layout.addWidget(self.epg_scroll) main_layout.addLayout(content_layout) self.setCentralWidget(main_widget) # === Link vertical scrollbars === self.epg_scroll.verticalScrollBar().valueChanged.connect( self.channel_scroll.verticalScrollBar().setValue ) self.channel_scroll.verticalScrollBar().valueChanged.connect( self.epg_scroll.verticalScrollBar().setValue ) def build_epg_grid(self): # Create a 3-hour timeline with 30-min slots now = datetime.utcnow().replace(tzinfo=pytz.utc).astimezone(pytz.timezone("Asia/Karachi")) timeline = [now + timedelta(minutes=30 * i) for i in range(6)] # Header: Time slots for col, t in enumerate(timeline): label = QLabel(t.strftime("%I:00 %p").lstrip("0")) label.setAlignment(Qt.AlignCenter) label.setStyleSheet("background-color: #333; padding: 6px; font-weight: bold;") self.epg_layout.addWidget(label, 0, col) # Rows: Channel EPG blocks for row, channel_id in enumerate(self.channel_ids, start=1): bg = "#333" if row % 2 else "#444" programs = [p for p in self.epg_data.findall(".//programme") if p.get("channel") == channel_id] for prog in programs: try: start = datetime.strptime(prog.get("start")[:14], "%Y%m%d%H%M%S").replace(tzinfo=pytz.utc).astimezone(pytz.timezone("Asia/Karachi")) stop = datetime.strptime(prog.get("stop")[:14], "%Y%m%d%H%M%S").replace(tzinfo=pytz.utc).astimezone(pytz.timezone("Asia/Karachi")) if stop < timeline[0] or start > timeline[-1]: continue title = prog.findtext("title", "No Title") start_offset = max(0, int((start - timeline[0]).total_seconds() // 1800)) duration_slots = max(1, int((stop - start).total_seconds() // 1800)) cell = QLabel(title) cell.setStyleSheet(f"background-color: {bg}; border: 1px solid #555; padding: 5px;") cell.setWordWrap(True) self.epg_layout.addWidget(cell, row, start_offset, 1, duration_slots) except: continue def start_php_server(php_dir, port=8888): try: os.chdir(php_dir) return subprocess.Popen([ "php", "-S", f"localhost:{port}"], stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL, creationflags=subprocess.CREATE_NO_WINDOW if sys.platform == "win32" else 0 ) except Exception as e: print(f"Failed to start PHP server: {e}") return None if __name__ == "__main__": php_dir = os.path.join(os.path.dirname(__file__), "php_files") os.makedirs(php_dir, exist_ok=True) php_proc = start_php_server(php_dir) app = QApplication(sys.argv) window = IPTVWindow(php_dir) window.show() exit_code = app.exec_() # Ensure clean exit if php_proc: php_proc.terminate() php_proc.wait(2) sys.exit(exit_code)