Course gives an introduction into how media content is created, distributed, received, processed and played back in today’s Digital TV and multimedia standards, applications and software stacks. Specific consideration is given to the reception stage, including demultiplexing, metadata parsing, descrambling, synchronization and decoding, and to how these operations are integrated through layered software stacks, media frameworks, middleware and modern application runtimes. The course covers both broadcast and broadband delivery, including managed IPTV and OTT, and introduces practical standards and technologies such as MPEG-TS, PES, DVB/ATSC signalling, HTTP adaptive streaming, media codecs and Android TV APIs. The course has a strong practical dimension: students first develop signal-path architectures and UML sequence diagrams, then design and implement an Android TV application using the TV Input Framework, broadcast middleware and OTT playback. Laboratory and project work uses Android Studio and an Android 16 Cuttlefish environment, while Linux and HTML-based media platforms are also discussed as important alternatives used in commercial media receivers.
M1: Introduction to Digital TV and Multimedia
https://academy.nit-institute.com/wp-content/uploads/2025/05/L1.png
The goal of this lecture is to introduce the media landscape and explain how content, formats, platforms and audience reach shape modern media systems. We follow the complete media lifecycle through production, distribution and consumption, comparing institutional, digital, social and emerging media. We then focus on digital TV and multimedia, distinguishing broadcast delivery from managed IPTV and OTT. Using examples such as BBC and Netflix, we introduce content packaging, transmission, reception and playback, together with the difference between media data and metadata. The lecture also examines media value chains and the roles of content creators, broadcasters, telecom operators, platform providers and device manufacturers.
Explore end-to-end media delivery scenarios and identify the main processing stages, signal flows, data and metadata needed to bring content from production to the consumer.
2 hours 30 minutes
M2: Media Production and Receiver Architecture
https://academy.nit-institute.com/wp-content/uploads/2025/05/L2.png
This lecture decomposes the production and consumption stages into concrete processing blocks. On the production side, we examine versioning, audio/video coding, metadata preparation, program stream packaging, multiplexing, MPEG transport stream formation, scrambling and publishing for broadcast and OTT. On the reception side, we introduce the tuner and demodulator, error correction, conditional access, demultiplexer, CPU command and control, dedicated audio/video decoders, GPU composition and device interfaces. We compare live broadcast playback with IP-based streaming and show how hardware blocks and software tasks form a complete signal path. The lecture also introduces dataflow diagrams and UML sequence diagrams as complementary views of media use cases.
Start Project 1 by modelling a selected media consumption use case. Draw its signal path, identify the main blocks and content flows, and describe command-and-control interactions using a UML sequence diagram.
2 hours 30 minutes
M3: Broadcast TV Standards, Formats and Metadata
https://academy.nit-institute.com/wp-content/uploads/2025/05/L3.png
In this lecture, we map concrete standards and data formats onto the broadcast media pipeline. We compare terrestrial, satellite and cable delivery through DVB, ATSC, ISDB and DTMB families, then examine MPEG-TS and PES packaging, transport packet headers, PIDs and demultiplexing. Special attention is given to PSI/SI and PSIP metadata, including PAT, PMT, SDT, EIT, CAT and other tables used for service discovery, program information and conditional access. We also explain broadcast timing through PCR, DTS and PTS, elementary video and audio coding, subtitle and teletext formats, and the role of ECM and EMM messages in scrambled services. These concepts connect broadcast standards directly to receiver software and the signal path.
Extend the Project 1 dataflow and UML sequence diagrams with broadcast standards, transport structures, PIDs, table parsing, synchronization information and concrete data types associated with each processing step.
2 hours 30 minutes
M4: Broadband TV Standards, Protocols and Adaptive Streaming
https://academy.nit-institute.com/wp-content/uploads/2025/05/L4.png
This lecture covers the technologies used for media delivery over IP, comparing managed IPTV networks with non-managed Internet TV and OTT services. We explore unicast and multicast transport, IP, UDP, TCP, IGMP, RTP and RTSP, alongside the role of network management and quality of service. We then examine OTT delivery over HTTP, adaptive streaming through MPEG-DASH and HLS, segment and fragment packaging in MPEG-TS, fragmented MP4/CMAF and WebM, and playlists such as MPD and M3U8. The lecture also introduces streaming metadata delivered through REST APIs and JSON/XML, multiple quality representations, modern codecs including AVC, HEVC, VVC, VP9 and AV1, subtitles, and DRM-based content protection. We trace these formats through concrete IPTV and OTT production and consumption pipelines.
Complete Project 1 by specifying formats, protocols and data types for broadband and OTT signal paths. Refine the UML interactions for adaptive streaming, metadata retrieval, playback control and changing network conditions, then present the finished architecture.
2 hours 30 minutes
M5: Media Device Software Stack Architecture
https://academy.nit-institute.com/wp-content/uploads/2025/05/L5.png
This lecture begins the software-focused part of the course. We connect the previously studied receiver hardware to its host software and introduce a layered stack consisting of hardware abstraction (HAL), platform abstraction (PAL), middleware and applications. We explain drivers, register access and peripheral interfaces, then distinguish hardware capabilities from programmer-oriented platform abstractions. The platform layer includes the operating system, common libraries and domain-specific SDKs. We examine the roles of DTV SDKs, media playback frameworks, conditional access SDKs and application runtimes in Android and Linux-plus-web systems. Finally, we explain how software layers translate user requests into concrete hardware operations, which companies typically provide the various layers, and why portability, wrappers and system integration matter.
Begin Project 2 architecture work. Identify the HAL, PAL, middleware and application components needed for a TV service and sketch the corresponding API-call hierarchy, resource ownership and software interfaces.
2 hours 30 minutes
M6: Media Device Software Platform (HAL/PAL)
https://academy.nit-institute.com/wp-content/uploads/2025/05/L6.png
This lecture examines platform APIs in practical detail, using Broadcom Nexus as an example of a vendor DTV SDK. We explore its module and filter-graph concepts, especially InputBand, ParserBand, PidChannel, decoder, display and synchronization abstractions used to build processing pipelines. We then compare Linux-oriented interfaces with Android’s Tuner Framework, Tuner SDK and Tuner HAL, including resource management through TRM, Java/native boundaries through JNI, and playback through MediaCodec and AudioTrack. Detailed UML sequences explain frontend tuning, section filtering and PAT/PMT parsing, A/V playback configuration, synchronization and pass-through versus memory-buffer decoding. The lecture demonstrates how middleware requests map through standard APIs into vendor SDK operations.
Develop implementation-oriented UML examples for tuning, demux filter creation, table parsing and playback setup. Map Android API calls to platform abstractions and show asynchronous callbacks and buffer exchanges where appropriate.
2 hours 30 minutes
M7: DTV Middleware and Android TV Application Integration
https://academy.nit-institute.com/wp-content/uploads/2025/05/L7.png
This lecture opens the DTV middleware layer and explains how broadcast functionality becomes available to Android TV applications. We introduce Android Runtime and the TV Input Framework (TIF), TV Input Services, TV Input Manager and TV Provider, then examine the Comedia broadcast middleware architecture and its platform-independent CHAL glue layer. Inside middleware, we study Scan Control, Service Control, Player, EPG, PVR, service and event databases, PSI/SI table parsing, application engines and signal-path orchestration. Using detailed UML sequence diagrams, we follow first-time service installation by scanning a simulated MPEG-TS file and then activating a selected service through broadcast zapping. We show how Java and native calls, background tasks, callbacks, service triplets, media decoders and Android surfaces cooperate to complete a real TV use case.
Prepare the Project 2 implementation design: define broadcast and OTT TV Inputs, integrate service discovery with TV Provider, and model service installation, broadcast zapping, OTT zapping and metadata-related operations using UML sequence diagrams.
2 hours 30 minutes
M8: Practical Project – Android TV Application with Broadcast and OTT
none
The final practical module brings the architecture to life in Android Studio and an Android 16 Cuttlefish environment. Students implement a TV application that presents a unified service list, supports channel zapping and shows service information from both broadcast and OTT sources. Broadcast reception is simulated using MPEG transport stream files and integrated through a Broadcast TV Input and Comedia middleware. The custom OTT TV Input retrieves service information from a server using HTTP and JSON/XML and delegates stream playback to Android media components. Both sources are integrated according to TV Input Framework design patterns, including first-time service discovery and updates to Android TV Provider. Work progresses from a detailed software architecture and UML sequences to source code, a working APK and a live demonstration.
Project 2 is delivered in two parts. First, submit the HAL/PAL/application-layer block architecture and implementation-oriented UML sequences covering service installation, broadcast zapping, OTT zapping and an additional selected scenario. Then submit the design specification, matching source code, working APK and demonstration. Testing should include different TS file inputs and OTT service metadata.
16 hours
Final exam
none
none
none
1 hour 30 minutes
