Patent 8949206

Derivative works

Defensive disclosure: derivative variations of each claim designed to render future incremental improvements obvious or non-novel.

Active provider: Google · gemini-2.5-pro

Derivative works

Defensive disclosure: derivative variations of each claim designed to render future incremental improvements obvious or non-novel.

✓ Generated

Defensive Disclosure: Methods for Dynamic Generation of Media and Data Manifests

Publication Date: May 11, 2026
Field: Digital Media Distribution, Data Streaming, Cloud Computing, Internet of Things (IoT)

This document discloses several methods, systems, and applications related to the dynamic generation and modification of descriptor files (manifests) for segmented media and data streams. These disclosures are intended to enter the public domain to serve as prior art for future patent applications. The core concept involves creating multiple, customized versions of a data stream by manipulating a manifest file based on a set of rules, without regenerating or transcoding the underlying data segments.

Derivative Variation 1: Serverless, Just-In-Time Manifest Generation

  • Enabling Description: This variation implements the manifest generation logic within a serverless computing environment (e.g., AWS Lambda, Google Cloud Functions, Azure Functions). A master manifest file (e.g., a DASH MPD or HLS playlist) and all associated media segments are stored in a cloud object storage service (e.g., S3, Google Cloud Storage). A set of versioning rules is stored in a low-latency NoSQL database (e.g., DynamoDB, Firestore), mapping user IDs, device profiles, or geographic locations to specific content rules (e.g., "remove_period_3", "substitute_audio_track_en-us").

    When a client requests a manifest, the request is routed through an API Gateway, which triggers a dedicated serverless function. This function:

    1. Retrieves the master manifest from object storage.
    2. Reads request headers or parameters (e.g., JWT token, query string) to identify the user and context.
    3. Queries the NoSQL database to fetch the applicable rules for that context.
    4. Parses the master manifest (e.g., as an XML DOM or text stream) and applies the rules by programmatically adding, removing, or modifying nodes/tags or text lines. For example, it might remove a <Period> element or replace a <BaseURL> to redirect a client to a different ad server.
    5. Returns the newly generated, non-persistent manifest directly to the client as the HTTP response.

    This architecture eliminates the need for a constantly running server, reduces cost, and scales massively and automatically with demand. The manifest manipulation logic is stateless, making it highly robust.

  • Mermaid Diagram:

    sequenceDiagram
    participant Client
    participant APIGateway as API Gateway
    participant Lambda as "Manifest Generator (Lambda)"
    participant S3 as "Object Storage (S3)"
    participant DynamoDB as "Rules Database (DynamoDB)"

    Client->>+APIGateway: GET /manifest.mpd?user=123
    APIGateway->>+Lambda: Invoke(event)
    Lambda->>+S3: GetObject(master.mpd)
    S3-->>-Lambda: master.mpd content
    Lambda->>+DynamoDB: GetItem(user:123)
    DynamoDB-->>-Lambda: {rule: "remove_period_3"}
    Lambda->>Lambda: Manipulate MPD in-memory
    Lambda-->>-APIGateway: Return modified_manifest.mpd
    APIGateway-->>-Client: 200 OK (body: modified_manifest.mpd)

Derivative Variation 2: Real-time Live Event Manifest Splicing

  • Enabling Description: This variation applies the concept to ultra-low latency live streaming, such as for sports or interactive events. A live encoder produces media segments and a continuously updated manifest file. A separate "Rules Engine" ingests real-time data from external APIs (e.g., sports statistics, betting odds, social media sentiment, biometric sensor data).

    A "Manifest Splicer" component intercepts the client's requests for the live manifest. For each request, it:

    1. Fetches the latest live manifest from the origin.
    2. Queries the Rules Engine for any active real-time events.
    3. If an event is active (e.g., a goal is scored), the Splicer modifies the manifest to insert a new "Period" or segment URL that points to a pre-canned instant replay or a graphical overlay. This is achieved by adjusting the presentationTimeOffset and segment lists.
    4. For personalized streams, the Rules Engine may provide user-specific rules, such as inserting a "picture-in-picture" period for an alternate camera angle that the user has expressed interest in, or embedding custom metadata tags (e.g., SCTE-35 markers in a new format) that the client player can interpret. This manipulation occurs in real-time, with each manifest update, allowing for a highly dynamic and interactive viewing experience without re-encoding the primary live stream.

  • Mermaid Diagram:

    graph TD
    A[Live Encoder] -->|Generates Segments & Live Manifest| B(Origin Server)
    C[Real-Time Data Feeds<br/>(Stats, Betting Odds)] --> D{Rules Engine}
    E[Client Device] -->|1. Request manifest.mpd| F(Manifest Splicer)
    F -->|2. Fetch latest manifest| B
    F -->|3. Query for rules| D
    D -->|4. Return dynamic rules<br/>(e.g., 'Insert Replay at timestamp X')| F
    F -->|5. Manipulate Manifest| F
    F -->|6. Return Spliced Manifest| E
    E -->|7. Request media segments| B

Derivative Variation 3: Application to Industrial IoT (IIoT) Digital Twins

  • Enabling Description: This concept is applied to the monitoring and control of industrial equipment (e.g., a jet engine, a factory robot) via a "Digital Twin" model. The physical asset is instrumented with hundreds of sensors (temperature, pressure, vibration, RPM), each generating a time-series data stream. These streams are segmented and described by a master "Data Stream Descriptor" (DSD), analogous to a media manifest.

    Different consumers of this data require different versions:

    • On-site Technician: Needs a low-latency, high-frequency stream of a core set of operational parameters.
    • Remote Analyst: Requires a historical view, with down-sampled data for long-term trend analysis, and enriched with data from maintenance logs.
    • Predictive Maintenance AI: Needs high-fidelity data from specific components (e.g., bearings, fuel injectors) but only for specific operational windows.

    A "Digital Twin Gateway" receives requests for data. Based on the requester's role (the "rule"), it manipulates the master DSD. For the technician, it generates a DSD pointing only to the latest, real-time segment URLs. For the analyst, it generates a DSD that combines historical segment URLs with pointers to log files. For the AI, it generates a DSD that filters out all irrelevant sensor streams and periods of inactivity. This avoids transferring massive, unnecessary datasets and provides each consumer with a perfectly tailored view of the asset's data without altering the raw, archived sensor readings.

  • Mermaid Diagram:

    flowchart LR
    subgraph Physical Asset
        S1(Sensor: Temp)
        S2(Sensor: Pressure)
        S3(Sensor: Vibration)
    end

    subgraph Cloud Platform
        Store[Data Lake /<br>Segment Storage]
        MasterDSD(Master Data<br>Stream Descriptor)
        Gateway(Digital Twin Gateway)
        Rules[Role-Based<br>Access Rules]
    end

    subgraph Consumers
        Tech(Technician App)
        Analyst(Analytics Dashboard)
        AI(ML Model)
    end

    S1 -- Data Segments --> Store
    S2 -- Data Segments --> Store
    S3 -- Data Segments --> Store
    Store -- References --> MasterDSD

    Tech -- Request(role=technician) --> Gateway
    Analyst -- Request(role=analyst) --> Gateway
    AI -- Request(role=ml_bot) --> Gateway

    Gateway -- Reads --> MasterDSD
    Gateway -- Reads --> Rules
    Gateway -->|Generates Custom DSD 1| Tech
    Gateway -->|Generates Custom DSD 2| Analyst
    Gateway -->|Generates Custom DSD 3| AI

Derivative Variation 4: Application to Personalized Pharmaceutical Manufacturing (Pharma 4.0)

  • Enabling Description: In a continuous manufacturing process for personalized medicine, a batch of a drug is produced according to a patient-specific formula. The process is documented by a stream of data from process analytical technology (PAT) sensors, logging every variable (temperature, flow rate, chemical concentration) in real-time. This entire data history is represented by a master "Batch Process Record" (BPR) manifest, which points to immutable, time-stamped data segments.

    A regulatory agency, a quality assurance (QA) auditor, and a research scientist may each need to review this BPR. The rules are based on their access credentials and purpose.

    • Regulator: Receives a BPR manifest that includes all critical process parameters (CPPs) and quality attributes (CQAs) but redacts proprietary formulation data.
    • QA Auditor: Receives a manifest that highlights deviations from the "golden batch" profile by inserting links to non-conformance reports at the specific timecodes where deviations occurred.
    • Researcher: Receives a manifest that includes all sensor data plus links to genomic data for the patient, allowing for deep analysis.

    A validated "BPR Generation Service" creates these role-specific manifest versions on-demand by manipulating the master BPR manifest, ensuring data integrity while providing customized, compliant views of the manufacturing process.

  • Mermaid Diagram:

    erDiagram
    "MASTER BPR" {
        string MasterBPR_ID
        string BatchID
    }
    "DATA SEGMENT" {
        string SegmentID
        string Timestamp
        string SensorType
        string DataURL
    }
    "RULE" {
        string RoleID
        string RedactionFilter
        string AnnotationSource
    }
    "CONSUMER" {
        string ConsumerID
        string RoleID
    }
    "MASTER BPR" ||--o{ "DATA SEGMENT" : "references"
    "CONSUMER" ||--|{ "RULE" : "is_subject_to"

Derivative Variation 5: Application to Modular Software & Firmware Delivery

  • Enabling Description: This variation applies the concept to Over-The-Air (OTA) updates for complex systems like automobiles or smart home devices. The complete firmware is composed of dozens of independent modules (e.g., engine control unit, infotainment, advanced driver-assistance systems). A master "Firmware Manifest" (e.g., a JSON or XML file) lists all possible modules, their versions, and URLs to their binary packages.

    When a specific device requests an update, it provides its model number, hardware revision, and current software version. The OTA update server uses these as "rules" to manipulate the master manifest:

    1. It filters out modules not compatible with the device's hardware revision.
    2. It removes modules for features the user has not subscribed to (e.g., a "performance pack" or "premium connectivity").
    3. It adjusts dependency information and signs the new, customized manifest.

    The device receives a much smaller, tailored manifest containing only the download links for the specific modules it needs. This reduces download size, minimizes the risk of flashing incompatible components, and enables feature management via software, all without needing to pre-package and store hundreds of unique full-firmware images.

  • Mermaid Diagram:

    graph TD
    subgraph OTA Server
        A(Master Firmware Manifest)
        B{Rule Engine}
        C(Module Storage)
    end

    subgraph Vehicle
        D[ECU]
        D -- "Request Update<br>(Model: Y, HW: 2.1, Subscription: Premium)" --> B
    end

    B -- "1. Read" --> A
    B -- "2. Apply Rules" --> E(Generate Custom Manifest)
    E -- "3. Contains URLs to:" --> C
    E -- "4. Send to Vehicle" --> D

    subgraph Custom_Manifest_for_Vehicle_D
        direction LR
        F[Infotainment_v3.bin]
        G[ADAS_Premium_v1.2.bin]
    end
    style Custom_Manifest_for_Vehicle_D fill:#f9f,stroke:#333,stroke-width:2px

    E -.-> Custom_Manifest_for_Vehicle_D

Derivative Variation 6: AI-Driven Predictive Manifest Caching

  • Enabling Description: This variation integrates a predictive AI model into the content delivery network (CDN). The AI model analyzes large-scale data, including historical user viewing patterns, time of day, geographic location, and trending social media topics. Based on this analysis, the model predicts which versions of a manifest will be most in-demand in the near future for a given piece of content.

    For example, if a major news event breaks in Germany, the AI predicts a surge in requests for the German-language audio track. It proactively instructs the manifest generator to create and pre-cache the "German language" version of the manifest at edge servers located in Europe. When a user in Germany requests the content, the CDN can serve the already-generated, customized manifest instantly, reducing the latency of on-the-fly generation. This combines dynamic, rule-based generation with intelligent, predictive caching to optimize performance at a global scale.

  • Mermaid Diagram:

    sequenceDiagram
    participant AI as "Predictive AI Engine"
    participant Generator as "Central Manifest Generator"
    participant Edge as "CDN Edge Cache"
    participant User

    loop Proactive Caching
        AI->>Generator: Predicts demand for 'de-DE' lang in 'eu-central-1' region
        Generator->>Generator: Generate 'de-DE' manifest version
        Generator->>Edge: PUSH manifest_de.mpd
    end

    User->>+Edge: GET /video/manifest.mpd (from Germany)
    alt Cache Hit
        Edge-->>-User: 200 OK (from cache)
    else Cache Miss
        Edge->>+Generator: GET /video/manifest.mpd?lang=de-DE
        Generator->>Generator: Generate 'de-DE' manifest on-the-fly
        Generator-->>-Edge: 200 OK (body: manifest_de.mpd)
        Edge-->>-User: 200 OK
    end

Derivative Variation 7: Blockchain-Audited Content Delivery

  • Enabling Description: To ensure transparency and verifiability in content delivery, especially for ad insertion or rights-managed content, this variation integrates the manifest generator with a distributed ledger (blockchain).

    When the system generates a custom manifest for a user, it performs the following steps:

    1. Manipulates the source manifest according to the rules (e.g., inserts a specific ad).
    2. Calculates a cryptographic hash (e.g., SHA-256) of the generated manifest.
    3. Records a transaction on a blockchain. The transaction includes the user's anonymized ID, a hash of the master content, the hash of the generated manifest, and the rule(s) applied (e.g., "ad_campaign_xyz").
    4. The manifest, along with the transaction ID, is delivered to the client.

    This creates an immutable, auditable, and time-stamped record of exactly which version of the content was delivered to which user. This can be used to independently verify ad delivery for advertisers, calculate royalty payments for different content snippets (e.g., music in a film), and prove compliance with regional content restrictions.

  • Mermaid Diagram:

    flowchart TD
    A[Client Request for Content] --> B{Manifest Generator};
    C[Rules Engine] --> B;
    D[Source MPD] --> B;

    B --> E{Generate Custom MPD};
    E --> F[Calculate Hash of Custom MPD];
    F --> G[Construct Blockchain Transaction<br>Includes: UserID, ContentHash, MPD_Hash, Rules];
    G --> H((Blockchain Network));
    H --> I{Confirm Transaction};

    subgraph Delivery
        E --> J[Deliver Custom MPD to Client];
        I --> K[Deliver Transaction ID to Client];
    end

Derivative Variation 8: Failsafe Manifest with Tiered Degradation

  • Enabling Description: This "inverse" design focuses on system resilience. The manifest generation system operates in a tiered state model. The default state is "Full Dynamic," where all rules are applied to create a personalized manifest. The system includes health checks for all external dependencies, such as the ad decision server, personalization database, and rights management API.

    • State 1: Full Dynamic: All systems are healthy. Manifests are fully customized.
    • State 2: Degraded - No Ads: If the ad server is unresponsive, the rules engine enters a degraded state. It manipulates the master manifest to remove all ad break periods, ensuring uninterrupted content playback.
    • State 3: Degraded - No Personalization: If the user profile service is unavailable, the rules engine falls back to serving a generic, non-personalized manifest for the user's region, which may still include ads.
    • State 4: Failsafe - Core Content Only: If multiple systems fail or the manifest manipulator itself encounters a critical error, the system serves a pre-generated, static, "failsafe" manifest. This manifest is a bare-bones version containing only the primary video and audio tracks, with no ads, subtitles, or alternate angles. This ensures the user can still watch the main content even during a partial system outage.

  • Mermaid Diagram:

    stateDiagram-v2
    [*] --> Full_Dynamic: System Initialized
    Full_Dynamic --> Degraded_NoAds: Ad_Server_Timeout
    Full_Dynamic --> Degraded_NoPersonalization: UserDB_Timeout
    Degraded_NoAds --> Failsafe: UserDB_Timeout
    Degraded_NoPersonalization --> Failsafe: Ad_Server_Timeout
    Degraded_NoAds --> Full_Dynamic: Services Restored
    Degraded_NoPersonalization --> Full_Dynamic: Services Restored
    Failsafe --> Full_Dynamic: All Services Restored

Combination Prior Art Scenarios with Open-Source Standards

  1. Combination with W3C Data Integrity Proofs: The system generates a custom manifest file in JSON-LD (JSON for Linked Data) format. Before distribution, the manifest is signed using a cryptographic suite compatible with the W3C Verifiable Credentials Data Model. The manifest includes a proof block containing the signature, verification method (e.g., a public key), and other metadata. This allows a client to cryptographically verify that the manifest was generated by an authorized server and has not been tampered with, which is critical when rules are used to enforce content restrictions or blackouts.

  2. Combination with IETF SCITT (Supply Chain Integrity, Transparency, and Trust): The creation of each derivative manifest is treated as an event in a supply chain. A master manifest is the initial "product." The manifest generator acts as a "producer" that issues a signed statement for each generated manifest. These statements are registered in a SCITT-compliant transparent ledger. This allows downstream systems (e.g., CDNs, clients) to audit the entire history of a manifest, verifying which rules were applied by which system at what time, thus proving the integrity of the content delivery process according to a formal, open standard.

  3. Combination with CNCF OpenTelemetry: The manifest manipulation system is instrumented using the OpenTelemetry standard. Every step of the process—receiving the request, fetching rules, parsing the master manifest, applying each rule, and generating the final output—emits detailed traces and metrics. These are sent to a compatible backend (e.g., Jaeger, Prometheus). This allows operators to precisely debug performance bottlenecks (e.g., a slow rule lookup), track the popularity of different content versions (e.g., which language tracks are most requested), and set alerts for high error rates in the manifest generation process, using a widely adopted, open-source observability framework.

Generated 5/11/2026, 6:05:49 PM