/**
 * Copyright 2015 Mozilla Foundation
 * Copyright 2016 - 2020 Stephan Hesse, EMLIRI (c)
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
import { Box, BoxContainerBox, FullBox } from './mp4iso-base';
export declare const START_DATE = -2082844800000;
export declare const DEFAULT_MOVIE_MATRIX: number[];
export declare const DEFAULT_OP_COLOR: number[];
export declare class FileTypeBox extends Box {
    majorBrand: string;
    minorVersion: number;
    compatibleBrands: string[];
    constructor(majorBrand: string, minorVersion: number, compatibleBrands: string[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class MovieBox extends BoxContainerBox {
    header: MovieHeaderBox;
    tracks: Box[];
    extendsBox: MovieExtendsBox;
    userData: Box;
    constructor(header: MovieHeaderBox, tracks: Box[], extendsBox: MovieExtendsBox, userData: Box);
}
export declare class MovieHeaderBox extends FullBox {
    timescale: number;
    duration: number;
    nextTrackId: number;
    rate: number;
    volume: number;
    matrix: number[];
    creationTime: number;
    modificationTime: number;
    constructor(timescale: number, duration: number, nextTrackId: number, rate?: number, volume?: number, matrix?: number[], creationTime?: number, modificationTime?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare enum TrackHeaderFlags {
    TRACK_ENABLED = 1,
    TRACK_IN_MOVIE = 2,
    TRACK_IN_PREVIEW = 4
}
export declare class TrackHeaderBox extends FullBox {
    trackId: number;
    duration: number;
    width: number;
    height: number;
    volume: number;
    alternateGroup: number;
    layer: number;
    matrix: number[];
    creationTime: number;
    modificationTime: number;
    constructor(flags: number, trackId: number, duration: number, width: number, height: number, volume: number, alternateGroup?: number, layer?: number, matrix?: number[], creationTime?: number, modificationTime?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class MediaHeaderBox extends FullBox {
    timescale: number;
    duration: number;
    language: string;
    creationTime: number;
    modificationTime: number;
    constructor(timescale: number, duration: number, language?: string, creationTime?: number, modificationTime?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class HandlerBox extends FullBox {
    handlerType: string;
    name: string;
    private _encodedName;
    constructor(handlerType: string, name: string);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class SoundMediaHeaderBox extends FullBox {
    balance: number;
    constructor(balance?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class VideoMediaHeaderBox extends FullBox {
    graphicsMode: number;
    opColor: number[];
    constructor(graphicsMode?: number, opColor?: number[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare var SELF_CONTAINED_DATA_REFERENCE_FLAG: number;
export declare class DataEntryUrlBox extends FullBox {
    location: string;
    private _encodedLocation;
    constructor(flags: number, location?: string);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class DataReferenceBox extends FullBox {
    entries: Box[];
    constructor(entries: Box[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class DataInformationBox extends BoxContainerBox {
    dataReference: Box;
    constructor(dataReference: Box);
}
export declare class SampleDescriptionBox extends FullBox {
    entries: Box[];
    constructor(entries: Box[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare type DecodingTimeToSampleEntry = {
    sampleCount: number;
    sampleDelta: number;
};
export declare class DecodingTimeToSampleBox extends FullBox {
    entries: DecodingTimeToSampleEntry[];
    constructor(flags: number, entries: DecodingTimeToSampleEntry[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
/**
 * This box provides the offset between decoding time and composition time.
 *
 * Since decoding time must be less than  the  composition  time,
 * the  offsets  are  expressed  as  unsigned  numbers  such  that CT(n)  =  DT(n)  +  CTTS(n)
 * where CTTS(n) is the (uncompressed) table entry for sample n.
 *
 * The composition time to sample table is optional and must only be present if DT and CT differ for any samples.
 */
export declare type CompositionTimeToSampleEntry = {
    sampleCount: number;
    sampleOffset: number;
};
export declare class CompositionTimeToSampleBox extends FullBox {
    entries: CompositionTimeToSampleEntry[];
    constructor(flags: number, entries: CompositionTimeToSampleEntry[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
/**
 * This box contains the sample count and a table giving the size in bytes of each sample.
 * This allows the media data itself to be unframed.
 * The total number of samples in the media is always indicated in the sample count.
 */
export declare class SampleSizeBox extends FullBox {
    sampleSizes: number[];
    sampleCount: number;
    defaultSampleSize: number;
    constructor(sampleSizes?: number[], sampleCount?: number, defaultSampleSize?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
/**
 * first_chunk is an integer that gives the index of the first chunk
 * in this run of chunks that share the same samples-per-chunk and sample-description-index;
 * the index of the first chunk in a track has the value 1
 * (the first_chunk field in the first record of this box has the value 1,
 * identifying that the first sample maps to the first chunk).
 *
 * samples_per_chunk is an integer that gives the number of samples in each of these chunks.
 *
 * sample_description_index is an integer that gives the index of the sample entry that describes the samples
 * in  this  chunk.  The  index  ranges  from  1  to  the  number  of  sample  entries  in  the  Sample  Description Box.
 */
export declare type SampleToChunkEntry = {
    firstChunk: number;
    samplesPerChunk: number;
    sampleDescriptionIndex: number;
};
export declare class SampleToChunkBox extends FullBox {
    entries: SampleToChunkEntry[];
    constructor(entries: SampleToChunkEntry[]);
    layout(offset: any): number;
    write(data: Uint8Array): number;
}
/**
 * The chunk offset table gives the index of each chunk into the containing file.
 *
 * There are two variants, permitting the use of 32-bit or 64-bit offsets.
 *
 * The latter is useful when managing very large presentations.
 * At most one of these variants will occur in any single instance of a sample table.
 * Offsets are file offsets, not the offset into any box within the file (e.g. Media Data Box).
 * This permits referring to media data in files without any box structure.
 * It does also mean that care must be taken when constructing a self-contained ISO file with its metadata (Movie Box) at the front,
 * as the size of the Movie Box will affect the chunk offsets to the media data.
 */
export declare class ChunkOffsetBox extends FullBox {
    chunkOffsets: number[];
    constructor(chunkOffsets: number[]);
    layout(offset: any): number;
    write(data: Uint8Array): number;
}
export declare class SyncSampleBox extends FullBox {
    syncSampleNumbers: number[];
    constructor(syncSampleNumbers: number[]);
    layout(offset: any): number;
    write(data: Uint8Array): number;
}
export declare type StblSample = {
    size: number;
    dts: number;
    cts: number;
    isRap: boolean;
    sampleDescriptionIndex: number;
};
/**
 * This box provides a compact marking of the random access points within the stream.
 *
 * The table is arranged in strictly increasing order of sample number.
 *
 * If the sync sample box is not present, every sample is a random access point.
 *
 * entry_count is an integer that gives the number of entries in the following table.
 *
 * If entry_count is zero, there are no random access points within the stream and the following table is empty.
 *
 * sample_number gives the numbers of the samples that are random access points in the stream.
 */
export declare class SampleTableBox extends BoxContainerBox {
    sampleDescriptions: SampleDescriptionBox;
    timeToSample: Box;
    compositionOffsetBox: Box;
    sampleToChunk: Box;
    sampleSizes: Box;
    chunkOffset: Box;
    syncSamples?: Box;
    constructor(sampleDescriptions: SampleDescriptionBox, timeToSample: Box, compositionOffsetBox: Box, sampleToChunk: Box, sampleSizes: Box, chunkOffset: Box, syncSamples?: Box);
}
export declare class MediaInformationBox extends BoxContainerBox {
    header: Box;
    info: DataInformationBox;
    sampleTable: SampleTableBox;
    constructor(header: Box, // SoundMediaHeaderBox|VideoMediaHeaderBox
    info: DataInformationBox, sampleTable: SampleTableBox);
}
export declare class MediaBox extends BoxContainerBox {
    header: MediaHeaderBox;
    handler: HandlerBox;
    info: MediaInformationBox;
    constructor(header: MediaHeaderBox, handler: HandlerBox, info: MediaInformationBox);
}
export declare class TrackBox extends BoxContainerBox {
    header: TrackHeaderBox;
    media: Box;
    constructor(header: TrackHeaderBox, media: Box);
}
export declare class TrackExtendsBox extends FullBox {
    trackId: number;
    defaultSampleDescriptionIndex: number;
    defaultSampleDuration: number;
    defaultSampleSize: number;
    defaultSampleFlags: number;
    constructor(trackId: number, defaultSampleDescriptionIndex: number, defaultSampleDuration: number, defaultSampleSize: number, defaultSampleFlags: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class MovieExtendsBox extends BoxContainerBox {
    header: Box;
    tracDefaults: TrackExtendsBox[];
    levels: Box;
    constructor(header: Box, tracDefaults: TrackExtendsBox[], levels: Box);
}
export declare class MetaBox extends FullBox {
    handler: Box;
    otherBoxes: Box[];
    constructor(handler: Box, otherBoxes: Box[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class MovieFragmentHeaderBox extends FullBox {
    sequenceNumber: number;
    constructor(sequenceNumber: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare enum TrackFragmentFlags {
    BASE_DATA_OFFSET_PRESENT = 1,
    SAMPLE_DESCRIPTION_INDEX_PRESENT = 2,
    DEFAULT_SAMPLE_DURATION_PRESENT = 8,
    DEFAULT_SAMPLE_SIZE_PRESENT = 16,
    DEFAULT_SAMPLE_FLAGS_PRESENT = 32
}
export declare class TrackFragmentHeaderBox extends FullBox {
    trackId: number;
    baseDataOffset: number;
    sampleDescriptionIndex: number;
    defaultSampleDuration: number;
    defaultSampleSize: number;
    defaultSampleFlags: number;
    constructor(flags: number, trackId: number, baseDataOffset: number, sampleDescriptionIndex: number, defaultSampleDuration: number, defaultSampleSize: number, defaultSampleFlags: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class TrackFragmentBaseMediaDecodeTimeBox extends FullBox {
    baseMediaDecodeTime: number;
    constructor(baseMediaDecodeTime: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class TrackFragmentBox extends BoxContainerBox {
    header: TrackFragmentHeaderBox;
    decodeTime: TrackFragmentBaseMediaDecodeTimeBox;
    run: TrackRunBox;
    constructor(header: TrackFragmentHeaderBox, decodeTime: TrackFragmentBaseMediaDecodeTimeBox, // move after run?
    run: TrackRunBox);
}
export declare enum SampleFlags {
    IS_LEADING_MASK = 201326592,
    SAMPLE_DEPENDS_ON_MASK = 50331648,
    SAMPLE_DEPENDS_ON_OTHER = 16777216,
    SAMPLE_DEPENDS_ON_NO_OTHERS = 33554432,
    SAMPLE_IS_DEPENDED_ON_MASK = 12582912,
    SAMPLE_HAS_REDUNDANCY_MASK = 3145728,
    SAMPLE_PADDING_VALUE_MASK = 917504,
    SAMPLE_IS_NOT_SYNC = 65536,
    SAMPLE_DEGRADATION_PRIORITY_MASK = 65535
}
export declare enum TrackRunFlags {
    DATA_OFFSET_PRESENT = 1,
    FIRST_SAMPLE_FLAGS_PRESENT = 4,
    SAMPLE_DURATION_PRESENT = 256,
    SAMPLE_SIZE_PRESENT = 512,
    SAMPLE_FLAGS_PRESENT = 1024,
    SAMPLE_COMPOSITION_TIME_OFFSET = 2048
}
export declare type TrackRunSample = {
    duration?: number;
    size?: number;
    flags?: number;
    compositionTimeOffset?: number;
};
export declare class TrackRunBox extends FullBox {
    samples: TrackRunSample[];
    dataOffset?: number;
    firstSampleFlags?: number;
    constructor(flags: number, samples: TrackRunSample[], dataOffset?: number, firstSampleFlags?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class MovieFragmentBox extends BoxContainerBox {
    header: MovieFragmentHeaderBox;
    trafs: TrackFragmentBox[];
    constructor(header: MovieFragmentHeaderBox, trafs: TrackFragmentBox[]);
}
export declare class MediaDataBox extends Box {
    chunks: Uint8Array[];
    constructor(chunks: Uint8Array[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class SampleEntry extends Box {
    dataReferenceIndex: number;
    constructor(format: string, dataReferenceIndex: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class AudioSampleEntry extends SampleEntry {
    channelCount: number;
    sampleSize: number;
    sampleRate: number;
    otherBoxes: Box[];
    constructor(codingName: string, dataReferenceIndex: number, channelCount?: number, sampleSize?: number, sampleRate?: number, otherBoxes?: Box[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare var COLOR_NO_ALPHA_VIDEO_SAMPLE_DEPTH: number;
export declare class VideoSampleEntry extends SampleEntry {
    width: number;
    height: number;
    compressorName: string;
    horizResolution: number;
    vertResolution: number;
    frameCount: number;
    depth: number;
    otherBoxes: Box[];
    constructor(codingName: string, dataReferenceIndex: number, width: number, height: number, compressorName?: string, horizResolution?: number, vertResolution?: number, frameCount?: number, depth?: number, otherBoxes?: Box[]);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}
export declare class AvcCodecDataBox extends Box {
    spsNALUs: Uint8Array[];
    ppsNALUs: Uint8Array[];
    profile: number;
    profileCompatibility: number;
    level: number;
    nalUnitSizeFieldLength: number;
    version: number;
    constructor(spsNALUs: Uint8Array[], ppsNALUs: Uint8Array[], profile: number, profileCompatibility: number, level: number, nalUnitSizeFieldLength?: number, version?: number);
    layout(offset: number): number;
    write(data: Uint8Array): number;
}