Skip to main content

FFV1 Video Coding Format Version 0, 1, and 3
draft-ietf-cellar-ffv1-10

The information below is for an old version of the document.
Document Type
This is an older version of an Internet-Draft that was ultimately published as RFC 9043.
Authors Michael Niedermayer , Dave Rice , Jérôme Martinez
Last updated 2019-10-10 (Latest revision 2019-09-06)
RFC stream Internet Engineering Task Force (IETF)
Formats
Reviews
Additional resources Mailing list discussion
Stream WG state Submitted to IESG for Publication
Associated WG milestone
Sep 2019
Submit informational specification for FFV1 video codec versions 0, 1 and 3 to IESG for publication
Document shepherd Peter Bubestinger-Steindl
Shepherd write-up Show Last changed 2019-02-28
IESG IESG state Became RFC 9043 (Informational)
Consensus boilerplate Unknown
Telechat date (None)
Responsible AD Adam Roach
Send notices to Michael Richardson <mcr+ietf@sandelman.ca>, "Peter B." <pb@das-werkstatt.com>
draft-ietf-cellar-ffv1-10
"configuration_record_crc_parity" 32 bits that are chosen so that the
   "Configuration Record" as a whole has a crc remainder of 0.

   This is equivalent to storing the crc remainder in the 32-bit parity.

   The CRC generator polynomial used is the standard IEEE CRC polynomial
   (0x104C11DB7) with initial value 0.

4.2.3.  Mapping FFV1 into Containers

   This "Configuration Record" can be placed in any file format
   supporting "Configuration Records", fitting as much as possible with
   how the file format uses to store "Configuration Records".  The
   "Configuration Record" storage place and "NumBytes" are currently
   defined and supported by this version of this specification for the
   following formats:

4.2.3.1.  AVI File Format

   The "Configuration Record" extends the stream format chunk ("AVI ",
   "hdlr", "strl", "strf") with the ConfigurationRecord bitstream.

   See [AVI] for more information about chunks.

Niedermayer, et al.       Expires 12 April 2020                [Page 34]
Internet-Draft                    FFV1                      October 2019

   "NumBytes" is defined as the size, in bytes, of the strf chunk
   indicated in the chunk header minus the size of the stream format
   structure.

4.2.3.2.  ISO Base Media File Format

   The "Configuration Record" extends the sample description box
   ("moov", "trak", "mdia", "minf", "stbl", "stsd") with a "glbl" box
   that contains the ConfigurationRecord bitstream.  See
   [ISO.14496-12.2015] for more information about boxes.

   "NumBytes" is defined as the size, in bytes, of the "glbl" box
   indicated in the box header minus the size of the box header.

4.2.3.3.  NUT File Format

   The codec_specific_data element (in "stream_header" packet) contains
   the ConfigurationRecord bitstream.  See [NUT] for more information
   about elements.

   "NumBytes" is defined as the size, in bytes, of the
   codec_specific_data element as indicated in the "length" field of
   codec_specific_data

4.2.3.4.  Matroska File Format

   FFV1 SHOULD use "V_FFV1" as the Matroska "Codec ID".  For FFV1
   versions 2 or less, the Matroska "CodecPrivate" Element SHOULD NOT be
   used.  For FFV1 versions 3 or greater, the Matroska "CodecPrivate"
   Element MUST contain the FFV1 "Configuration Record" structure and no
   other data.  See [Matroska] for more information about elements.

   "NumBytes" is defined as the "Element Data Size" of the
   "CodecPrivate" Element.

4.3.  Frame

   A "Frame" is an encoded representation of a complete static image.
   The whole "Frame" is provided by the underlaying container.

   A "Frame" consists of the keyframe field, "Parameters" (if version
   <=1), and a sequence of independent slices.  The pseudo-code below
   describes the contents of a "Frame".

Niedermayer, et al.       Expires 12 April 2020                [Page 35]
Internet-Draft                    FFV1                      October 2019

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   Frame( NumBytes ) {                                           |
       keyframe                                                  | br
       if (keyframe && !ConfigurationRecordIsPresent {           |
           Parameters( )                                         |
       }                                                         |
       while (remaining_bits_in_bitstream( NumBytes )) {         |
           Slice( )                                              |
       }                                                         |
   }                                                             |

   Architecture overview of slices in a "Frame":

    +-----------------------------------------------------------------+
    +=================================================================+
    | first slice header                                              |
    +-----------------------------------------------------------------+
    | first slice content                                             |
    +-----------------------------------------------------------------+
    | first slice footer                                              |
    +-----------------------------------------------------------------+
    | --------------------------------------------------------------- |
    +-----------------------------------------------------------------+
    | second slice header                                             |
    +-----------------------------------------------------------------+
    | second slice content                                            |
    +-----------------------------------------------------------------+
    | second slice footer                                             |
    +-----------------------------------------------------------------+
    | --------------------------------------------------------------- |
    +-----------------------------------------------------------------+
    | ...                                                             |
    +-----------------------------------------------------------------+
    | --------------------------------------------------------------- |
    +-----------------------------------------------------------------+
    | last slice header                                               |
    +-----------------------------------------------------------------+
    | last slice content                                              |
    +-----------------------------------------------------------------+
    | last slice footer                                               |
    +-----------------------------------------------------------------+

                                  Table 15

Niedermayer, et al.       Expires 12 April 2020                [Page 36]
Internet-Draft                    FFV1                      October 2019

4.4.  Slice

   A "Slice" is an independent spatial sub-section of a "Frame" that is
   encoded separately from an other region of the same "Frame".  The use
   of more than one "Slice" per "Frame" can be useful for taking
   advantage of the opportunities of multithreaded encoding and
   decoding.

   A "Slice" consists of a "Slice Header" (when relevant), a "Slice
   Content", and a "Slice Footer" (when relevant).  The pseudo-code
   below describes the contents of a "Slice".

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   Slice( ) {                                                    |
       if (version >= 3) {                                       |
           SliceHeader( )                                        |
       }                                                         |
       SliceContent( )                                           |
       if (coder_type == 0) {                                    |
           while (!byte_aligned()) {                             |
               padding                                           | u(1)
           }                                                     |
       }                                                         |
       if (version <= 1) {                                       |
           while (remaining_bits_in_bitstream( NumBytes ) != 0) {|
               reserved                                          | u(1)
           }                                                     |
       }                                                         |
       if (version >= 3) {                                       |
           SliceFooter( )                                        |
       }                                                         |
   }                                                             |

   "padding" specifies a bit without any significance and used only for
   byte alignment.  MUST be 0.

   "reserved" specifies a bit without any significance in this revision
   of the specification and may have a significance in a later revision
   of this specification.

   Encoders SHOULD NOT fill these bits.

   Decoders SHOULD ignore these bits.

   Note in case these bits are used in a later revision of this
   specification: any revision of this specification SHOULD care about
   avoiding to add 40 bits of content after "SliceContent" for version 0

Niedermayer, et al.       Expires 12 April 2020                [Page 37]
Internet-Draft                    FFV1                      October 2019

   and 1 of the bitstream.  Background: due to some non conforming
   encoders, some bitstreams where found with 40 extra bits
   corresponding to "error_status" and "slice_crc_parity", a decoder
   conforming to the revised specification could not do the difference
   between a revised bitstream and a buggy bitstream.

4.5.  Slice Header

   A "Slice Header" provides information about the decoding
   configuration of the "Slice", such as its spatial position, size, and
   aspect ratio.  The pseudo-code below describes the contents of the
   "Slice Header".

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   SliceHeader( ) {                                              |
       slice_x                                                   | ur
       slice_y                                                   | ur
       slice_width - 1                                           | ur
       slice_height - 1                                          | ur
       for (i = 0; i < quant_table_set_index_count; i++) {       |
           quant_table_set_index[ i ]                            | ur
       }                                                         |
       picture_structure                                         | ur
       sar_num                                                   | ur
       sar_den                                                   | ur
   }                                                             |

4.5.1.  slice_x

   "slice_x" indicates the x position on the slice raster formed by
   num_h_slices.

   Inferred to be 0 if not present.

4.5.2.  slice_y

   "slice_y" indicates the y position on the slice raster formed by
   num_v_slices.

   Inferred to be 0 if not present.

4.5.3.  slice_width

   "slice_width" indicates the width on the slice raster formed by
   num_h_slices.

   Inferred to be 1 if not present.

Niedermayer, et al.       Expires 12 April 2020                [Page 38]
Internet-Draft                    FFV1                      October 2019

4.5.4.  slice_height

   "slice_height" indicates the height on the slice raster formed by
   num_v_slices.

   Inferred to be 1 if not present.

4.5.5.  quant_table_set_index_count

   "quant_table_set_index_count" is defined as "1 + ( ( chroma_planes ||
   version <= 3 ) ? 1 : 0 ) + ( extra_plane ? 1 : 0 )".

4.5.6.  quant_table_set_index

   "quant_table_set_index" indicates the Quantization Table Set index to
   select the Quantization Table Set and the initial states for the
   slice.

   Inferred to be 0 if not present.

4.5.7.  picture_structure

   "picture_structure" specifies the temporal and spatial relationship
   of each "Line" of the "Frame".

   Inferred to be 0 if not present.

                    +-------+-------------------------+
                    | value | picture structure used  |
                    +=======+=========================+
                    | 0     | unknown                 |
                    +-------+-------------------------+
                    | 1     | top field first         |
                    +-------+-------------------------+
                    | 2     | bottom field first      |
                    +-------+-------------------------+
                    | 3     | progressive             |
                    +-------+-------------------------+
                    | Other | reserved for future use |
                    +-------+-------------------------+

                                  Table 16

4.5.8.  sar_num

   "sar_num" specifies the "Sample" aspect ratio numerator.

   Inferred to be 0 if not present.

Niedermayer, et al.       Expires 12 April 2020                [Page 39]
Internet-Draft                    FFV1                      October 2019

   A value of 0 means that aspect ratio is unknown.

   Encoders MUST write 0 if "Sample" aspect ratio is unknown.

   If "sar_den" is 0, decoders SHOULD ignore the encoded value and
   consider that "sar_num" is 0.

4.5.9.  sar_den

   "sar_den" specifies the "Sample" aspect ratio denominator.

   Inferred to be 0 if not present.

   A value of 0 means that aspect ratio is unknown.

   Encoders MUST write 0 if "Sample" aspect ratio is unknown.

   If "sar_num" is 0, decoders SHOULD ignore the encoded value and
   consider that "sar_den" is 0.

4.6.  Slice Content

   A "Slice Content" contains all "Line" elements part of the "Slice".

   Depending on the configuration, "Line" elements are ordered by
   "Plane" then by row (YCbCr) or by row then by "Plane" (RGB).

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   SliceContent( ) {                                             |
       if (colorspace_type == 0) {                               |
           for (p = 0; p < primary_color_count; p++) {           |
               for (y = 0; y < plane_pixel_height[ p ]; y++) {   |
                   Line( p, y )                                  |
               }                                                 |
           }                                                     |
       } else if (colorspace_type == 1) {                        |
           for (y = 0; y < slice_pixel_height; y++) {            |
               for (p = 0; p < primary_color_count; p++) {       |
                   Line( p, y )                                  |
               }                                                 |
           }                                                     |
       }                                                         |
   }                                                             |

Niedermayer, et al.       Expires 12 April 2020                [Page 40]
Internet-Draft                    FFV1                      October 2019

4.6.1.  primary_color_count

   "primary_color_count" is defined as "1 + ( chroma_planes ? 2 : 0 ) +
   ( extra_plane ? 1 : 0 )".

4.6.2.  plane_pixel_height

   "plane_pixel_height[ p ]" is the height in pixels of plane p of the
   slice.

   "plane_pixel_height[ 0 ]" and "plane_pixel_height[ 1 + (
   chroma_planes ? 2 : 0 ) ]" value is "slice_pixel_height".

   If "chroma_planes" is set to 1, "plane_pixel_height[ 1 ]" and
   "plane_pixel_height[ 2 ]" value is "ceil( slice_pixel_height /
   log2_v_chroma_subsample )".

4.6.3.  slice_pixel_height

   "slice_pixel_height" is the height in pixels of the slice.

   Its value is "floor( ( slice_y + slice_height ) * slice_pixel_height
   / num_v_slices ) - slice_pixel_y".

4.6.4.  slice_pixel_y

   "slice_pixel_y" is the slice vertical position in pixels.

   Its value is "floor( slice_y * frame_pixel_height / num_v_slices )".

4.7.  Line

   A "Line" is a list of the sample differences (relative to the
   predictor) of primary color components.  The pseudo-code below
   describes the contents of the "Line".

Niedermayer, et al.       Expires 12 April 2020                [Page 41]
Internet-Draft                    FFV1                      October 2019

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   Line( p, y ) {                                                |
       if (colorspace_type == 0) {                               |
           for (x = 0; x < plane_pixel_width[ p ]; x++) {        |
               sample_difference[ p ][ y ][ x ]                  |
           }                                                     |
       } else if (colorspace_type == 1) {                        |
           for (x = 0; x < slice_pixel_width; x++) {             |
               sample_difference[ p ][ y ][ x ]                  |
           }                                                     |
       }                                                         |
   }                                                             |

4.7.1.  plane_pixel_width

   "plane_pixel_width[ p ]" is the width in "Pixels" of "Plane" p of the
   slice.

   "plane_pixel_width[ 0 ]" and "plane_pixel_width[ 1 + ( chroma_planes
   ? 2 : 0 ) ]" value is "slice_pixel_width".

   If "chroma_planes" is set to 1, "plane_pixel_width[ 1 ]" and
   "plane_pixel_width[ 2 ]" value is "ceil( slice_pixel_width / (1 <<
   log2_h_chroma_subsample) )".

4.7.2.  slice_pixel_width

   "slice_pixel_width" is the width in "Pixels" of the slice.

   Its value is "floor( ( slice_x + slice_width ) * slice_pixel_width /
   num_h_slices ) - slice_pixel_x".

4.7.3.  slice_pixel_x

   "slice_pixel_x" is the slice horizontal position in "Pixels".

   Its value is "floor( slice_x * frame_pixel_width / num_h_slices )".

4.7.4.  sample_difference

   "sample_difference[ p ][ y ][ x ]" is the sample difference for
   "Sample" at "Plane" "p", y position "y", and x position "x".  The
   "Sample" value is computed based on median predictor and context
   described in the section on Samples (#samples).

Niedermayer, et al.       Expires 12 April 2020                [Page 42]
Internet-Draft                    FFV1                      October 2019

4.8.  Slice Footer

   A "Slice Footer" provides information about slice size and
   (optionally) parity.  The pseudo-code below describes the contents of
   the "Slice Footer".

   Note: "Slice Footer" is always byte aligned.

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   SliceFooter( ) {                                              |
       slice_size                                                | u(24)
       if (ec) {                                                 |
           error_status                                          | u(8)
           slice_crc_parity                                      | u(32)
       }                                                         |
   }                                                             |

4.8.1.  slice_size

   "slice_size" indicates the size of the slice in bytes.

   Note: this allows finding the start of slices before previous slices
   have been fully decoded, and allows parallel decoding as well as
   error resilience.

4.8.2.  error_status

   "error_status" specifies the error status.

             +-------+--------------------------------------+
             | value | error status                         |
             +=======+======================================+
             | 0     | no error                             |
             +-------+--------------------------------------+
             | 1     | slice contains a correctable error   |
             +-------+--------------------------------------+
             | 2     | slice contains a uncorrectable error |
             +-------+--------------------------------------+
             | Other | reserved for future use              |
             +-------+--------------------------------------+

                                 Table 17

4.8.3.  slice_crc_parity

   "slice_crc_parity" 32 bits that are chosen so that the slice as a
   whole has a crc remainder of 0.

Niedermayer, et al.       Expires 12 April 2020                [Page 43]
Internet-Draft                    FFV1                      October 2019

   This is equivalent to storing the crc remainder in the 32-bit parity.

   The CRC generator polynomial used is the standard IEEE CRC polynomial
   (0x104C11DB7) with initial value 0.

4.9.  Quantization Table Set

   The Quantization Table Sets are stored by storing the number of equal
   entries -1 of the first half of the table (represented as "len - 1"
   in the pseudo-code below) using the method described in Range Non
   Binary Values (#range-non-binary-values).  The second half doesn't
   need to be stored as it is identical to the first with flipped sign.
   "scale" and "len_count[ i ][ j ]" are temporary values used for the
   computing of "context_count[ i ]" and are not used outside
   Quantization Table Set pseudo-code.

   Example:

   Table: 0 0 1 1 1 1 2 2 -2 -2 -2 -1 -1 -1 -1 0

   Stored values: 1, 3, 1

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   QuantizationTableSet( i ) {                                   |
       scale = 1                                                 |
       for (j = 0; j < MAX_CONTEXT_INPUTS; j++) {                |
           QuantizationTable( i, j, scale )                      |
           scale *= 2 * len_count[ i ][ j ] - 1                  |
       }                                                         |
       context_count[ i ] = ceil( scale / 2 )                    |
   }                                                             |

   MAX_CONTEXT_INPUTS is 5.

Niedermayer, et al.       Expires 12 April 2020                [Page 44]
Internet-Draft                    FFV1                      October 2019

   pseudo-code                                                   | type
   --------------------------------------------------------------|-----
   QuantizationTable(i, j, scale) {                              |
       v = 0                                                     |
       for (k = 0; k < 128;) {                                   |
           len - 1                                               | ur
           for (a = 0; a < len; a++) {                           |
               quant_tables[ i ][ j ][ k ] = scale * v           |
               k++                                               |
           }                                                     |
           v++                                                   |
       }                                                         |
       for (k = 1; k < 128; k++) {                               |
           quant_tables[ i ][ j ][ 256 - k ] = \                 |
           -quant_tables[ i ][ j ][ k ]                          |
       }                                                         |
       quant_tables[ i ][ j ][ 128 ] = \                         |
       -quant_tables[ i ][ j ][ 127 ]                            |
       len_count[ i ][ j ] = v                                   |
   }                                                             |

4.9.1.  quant_tables

   "quant_tables[ i ][ j ][ k ]" indicates the quantification table
   value of the Quantized Sample Difference "k" of the Quantization
   Table "j" of the Set Quantization Table Set "i".

4.9.2.  context_count

   "context_count[ i ]" indicates the count of contexts for Quantization
   Table Set "i". "context_count[ i ]" MUST be less than or equal to
   32768.

5.  Restrictions

   To ensure that fast multithreaded decoding is possible, starting with
   version 3 and if "frame_pixel_width * frame_pixel_height" is more
   than 101376, "slice_width * slice_height" MUST be less or equal to
   "num_h_slices * num_v_slices / 4".  Note: 101376 is the frame size in
   "Pixels" of a 352x288 frame also known as CIF ("Common Intermediate
   Format") frame size format.

   For each "Frame", each position in the slice raster MUST be filled by
   one and only one slice of the "Frame" (no missing slice position, no
   slice overlapping).

   For each "Frame" with keyframe value of 0, each slice MUST have the

Niedermayer, et al.       Expires 12 April 2020                [Page 45]
Internet-Draft                    FFV1                      October 2019

   same value of "slice_x, slice_y, slice_width, slice_height" as a
   slice in the previous "Frame".

6.  Security Considerations

   Like any other codec, (such as [RFC6716]), FFV1 should not be used
   with insecure ciphers or cipher-modes that are vulnerable to known
   plaintext attacks.  Some of the header bits as well as the padding
   are easily predictable.

   Implementations of the FFV1 codec need to take appropriate security
   considerations into account, as outlined in [RFC4732].  It is
   extremely important for the decoder to be robust against malicious
   payloads.  Malicious payloads must not cause the decoder to overrun
   its allocated memory or to take an excessive amount of resources to
   decode.  The same applies to the encoder, even though problems in
   encoders are typically rarer.  Malicious video streams must not cause
   the encoder to misbehave because this would allow an attacker to
   attack transcoding gateways.  A frequent security problem in image
   and video codecs is also to not check for integer overflows in
   "Pixel" count computations, that is to allocate width * height
   without considering that the multiplication result may have
   overflowed the arithmetic types range.  The range coder could, if
   implemented naively, read one byte over the end.  The implementation
   must ensure that no read outside allocated and initialized memory
   occurs.

   The reference implementation [REFIMPL] contains no known buffer
   overflow or cases where a specially crafted packet or video segment
   could cause a significant increase in CPU load.

   The reference implementation [REFIMPL] was validated in the following
   conditions:

   *  Sending the decoder valid packets generated by the reference
      encoder and verifying that the decoder's output matches the
      encoder's input.

   *  Sending the decoder packets generated by the reference encoder and
      then subjected to random corruption.

   *  Sending the decoder random packets that are not FFV1.

   In all of the conditions above, the decoder and encoder was run
   inside the [VALGRIND] memory debugger as well as clangs address
   sanitizer [Address-Sanitizer], which track reads and writes to
   invalid memory regions as well as the use of uninitialized memory.
   There were no errors reported on any of the tested conditions.

Niedermayer, et al.       Expires 12 April 2020                [Page 46]
Internet-Draft                    FFV1                      October 2019

7.  Media Type Definition

   This registration is done using the template defined in [RFC6838] and
   following [RFC4855].

   Type name: video

   Subtype name: FFV1

   Required parameters: None.

   Optional parameters:

   This parameter is used to signal the capabilities of a receiver
   implementation.  This parameter MUST NOT be used for any other
   purpose.

   version: The version of the FFV1 encoding as defined by the section
   on version (#version).

   micro_version: The micro_version of the FFV1 encoding as defined by
   the section on micro_version (#micro-version).

   coder_type: The coder_type of the FFV1 encoding as defined by the
   section on coder_type (#coder-type).

   colorspace_type: The colorspace_type of the FFV1 encoding as defined
   by the section on colorspace_type (#colorspace-type).

   bits_per_raw_sample: The bits_per_raw_sample of the FFV1 encoding as
   defined by the section on bits_per_raw_sample (#bits-per-raw-sample).

   max-slices: The value of max-slices is an integer indicating the
   maximum count of slices with a frames of the FFV1 encoding.

   Encoding considerations:

   This media type is defined for encapsulation in several audiovisual
   container formats and contains binary data; see the section on
   "Mapping FFV1 into Containers" (#mapping-ffv1-into-containers).  This
   media type is framed binary data Section 4.8 of [RFC6838].

   Security considerations:

   See the "Security Considerations" section (#security-considerations)
   of this document.

   Interoperability considerations: None.

Niedermayer, et al.       Expires 12 April 2020                [Page 47]
Internet-Draft                    FFV1                      October 2019

   Published specification:

   [I-D.ietf-cellar-ffv1] and RFC XXXX.

   [RFC Editor: Upon publication as an RFC, please replace "XXXX" with
   the number assigned to this document and remove this note.]

   Applications which use this media type:

   Any application that requires the transport of lossless video can use
   this media type.  Some examples are, but not limited to screen
   recording, scientific imaging, and digital video preservation.

   Fragment identifier considerations: N/A.

   Additional information: None.

   Person & email address to contact for further information: Michael
   Niedermayer michael@niedermayer.cc (mailto:michael@niedermayer.cc)

   Intended usage: COMMON

   Restrictions on usage: None.

   Author: Dave Rice dave@dericed.com (mailto:dave@dericed.com)

   Change controller: IETF cellar working group delegated from the IESG.

8.  IANA Considerations

   The IANA is requested to register the following values:

   *  Media type registration as described in Media Type Definition
      (#media-type-definition).

9.  Appendixes

9.1.  Decoder implementation suggestions

9.1.1.  Multi-threading Support and Independence of Slices

   The FFV1 bitstream is parsable in two ways: in sequential order as
   described in this document or with the pre-analysis of the footer of
   each slice.  Each slice footer contains a slice_size field so the
   boundary of each slice is computable without having to parse the
   slice content.  That allows multi-threading as well as independence
   of slice content (a bitstream error in a slice header or slice
   content has no impact on the decoding of the other slices).

Niedermayer, et al.       Expires 12 April 2020                [Page 48]
Internet-Draft                    FFV1                      October 2019

   After having checked keyframe field, a decoder SHOULD parse
   slice_size fields, from slice_size of the last slice at the end of
   the "Frame" up to slice_size of the first slice at the beginning of
   the "Frame", before parsing slices, in order to have slices
   boundaries.  A decoder MAY fallback on sequential order e.g. in case
   of a corrupted "Frame" (frame size unknown, slice_size of slices not
   coherent...) or if there is no possibility of seeking into the
   stream.

10.  Changelog

   See https://github.com/FFmpeg/FFV1/commits/master
   (https://github.com/FFmpeg/FFV1/commits/master)

11.  Normative References

   [I-D.ietf-cellar-ffv1]
              Niedermayer, M., Rice, D., and J. Martinez, "FFV1 Video
              Coding Format Version 0, 1, and 3", Internet-Draft, draft-
              ietf-cellar-ffv1-09, 6 September 2019,
              <https://tools.ietf.org/html/draft-ietf-cellar-ffv1-09>.

   [ISO.15444-1.2016]
              International Organization for Standardization,
              "Information technology -- JPEG 2000 image coding system:
              Core coding system", October 2016.

   [ISO.9899.1990]
              International Organization for Standardization,
              "Programming languages - C", 1990.

   [RFC2119]  Bradner, S., "Key words for use in RFCs to Indicate
              Requirement Levels", BCP 14, RFC 2119,
              DOI 10.17487/RFC2119, March 1997,
              <https://www.rfc-editor.org/info/rfc2119>.

   [RFC4732]  Handley, M., Ed., Rescorla, E., Ed., and IAB, "Internet
              Denial-of-Service Considerations", RFC 4732,
              DOI 10.17487/RFC4732, December 2006,
              <https://www.rfc-editor.org/info/rfc4732>.

   [RFC4855]  Casner, S., "Media Type Registration of RTP Payload
              Formats", RFC 4855, DOI 10.17487/RFC4855, February 2007,
              <https://www.rfc-editor.org/info/rfc4855>.

   [RFC6716]  Valin, JM., Vos, K., and T. Terriberry, "Definition of the
              Opus Audio Codec", RFC 6716, DOI 10.17487/RFC6716,
              September 2012, <https://www.rfc-editor.org/info/rfc6716>.

Niedermayer, et al.       Expires 12 April 2020                [Page 49]
Internet-Draft                    FFV1                      October 2019

   [RFC6838]  Freed, N., Klensin, J., and T. Hansen, "Media Type
              Specifications and Registration Procedures", BCP 13,
              RFC 6838, DOI 10.17487/RFC6838, January 2013,
              <https://www.rfc-editor.org/info/rfc6838>.

12.  Informative References

   [Address-Sanitizer]
              The Clang Team, "ASAN AddressSanitizer website", undated,
              <https://clang.llvm.org/docs/AddressSanitizer.html>.

   [AVI]      Microsoft, "AVI RIFF File Reference", undated,
              <https://msdn.microsoft.com/en-us/library/windows/desktop/
              dd318189%28v=vs.85%29.aspx>.

   [FFV1_V0]  Niedermayer, M., "Commit to mark FFV1 version 0 as non-
              experimental", April 2006,
              <https://git.videolan.org/?p=ffmpeg.git;a=commit;h=b548f2b
              91b701e1235608ac882ea6df915167c7e>.

   [FFV1_V1]  Niedermayer, M., "Commit to release FFV1 version 1", April
              2009,
              <https://git.videolan.org/?p=ffmpeg.git;a=commit;h=68f8d33
              becbd73b4d0aa277f472a6e8e72ea6849>.

   [FFV1_V3]  Niedermayer, M., "Commit to mark FFV1 version 3 as non-
              experimental", August 2013,
              <https://git.videolan.org/?p=ffmpeg.git;a=commit;h=abe76b8
              51c05eea8743f6c899cbe5f7409b0f301>.

   [HuffYUV]  Rudiak-Gould, B., "HuffYUV", December 2003,
              <https://web.archive.org/web/20040402121343/
              http://cultact-server.novi.dk/kpo/huffyuv/huffyuv.html>.

   [ISO.14495-1.1999]
              International Organization for Standardization,
              "Information technology -- Lossless and near-lossless
              compression of continuous-tone still images: Baseline",
              December 1999.

   [ISO.14496-10.2014]
              International Organization for Standardization,
              "Information technology -- Coding of audio-visual objects
              -- Part 10: Advanced Video Coding", September 2014.

   [ISO.14496-12.2015]
              International Organization for Standardization,

Niedermayer, et al.       Expires 12 April 2020                [Page 50]
Internet-Draft                    FFV1                      October 2019

              "Information technology -- Coding of audio-visual objects
              -- Part 12: ISO base media file format", December 2015.

   [Matroska] IETF, "Matroska", 2016,
              <https://datatracker.ietf.org/doc/draft-lhomme-cellar-
              matroska/>.

   [NUT]      Niedermayer, M., "NUT Open Container Format", December
              2013, <https://ffmpeg.org/~michael/nut.txt>.

   [range-coding]
              Nigel, G. and N. Martin, "Range encoding: an algorithm for
              removing redundancy from a digitised message.", July 1979.

   [REFIMPL]  Niedermayer, M., "The reference FFV1 implementation / the
              FFV1 codec in FFmpeg", undated, <https://ffmpeg.org>.

   [VALGRIND] Valgrind Developers, "Valgrind website", undated,
              <https://valgrind.org/>.

   [YCbCr]    Wikipedia, "YCbCr", undated,
              <https://en.wikipedia.org/w/index.php?title=YCbCr>.

Authors' Addresses

   Michael Niedermayer

   Email: michael@niedermayer.cc

   Dave Rice

   Email: dave@dericed.com

   Jerome Martinez

   Email: jerome@mediaarea.net

Niedermayer, et al.       Expires 12 April 2020                [Page 51]