| /* |
| * Copyright © 2018, VideoLAN and dav1d authors |
| * Copyright © 2018, Two Orioles, LLC |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, this |
| * list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND |
| * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED |
| * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE |
| * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR |
| * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES |
| * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; |
| * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND |
| * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS |
| * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| // OBU parsing and bit magic all originally from dav1d's obu.c and getbits.c, |
| // but heavily modified/reduced down to simply find the Sequence Header OBU |
| // and pull a few interesting pieces from it. |
| // |
| // Any other code in here is under this license: |
| // |
| // Copyright 2020 Joe Drago. All rights reserved. |
| // SPDX-License-Identifier: BSD-2-Clause |
| |
| #include "avif/internal.h" |
| |
| #include <string.h> |
| |
| // --------------------------------------------------------------------------- |
| // avifBits - Originally dav1d's GetBits struct (see dav1d's getbits.c) |
| |
| typedef struct avifBits |
| { |
| int error, eof; |
| uint64_t state; |
| uint32_t bitsLeft; |
| const uint8_t *ptr, *start, *end; |
| } avifBits; |
| |
| static inline uint32_t avifBitsReadPos(const avifBits * bits) |
| { |
| return (uint32_t)(bits->ptr - bits->start) * 8 - bits->bitsLeft; |
| } |
| |
| static void avifBitsInit(avifBits * const bits, const uint8_t * const data, const size_t size) |
| { |
| bits->ptr = bits->start = data; |
| bits->end = &bits->start[size]; |
| bits->bitsLeft = 0; |
| bits->state = 0; |
| bits->error = 0; |
| bits->eof = 0; |
| } |
| |
| static void avifBitsRefill(avifBits * const bits, const uint32_t n) |
| { |
| uint64_t state = 0; |
| do { |
| state <<= 8; |
| bits->bitsLeft += 8; |
| if (!bits->eof) |
| state |= *bits->ptr++; |
| if (bits->ptr >= bits->end) { |
| bits->error = bits->eof; |
| bits->eof = 1; |
| } |
| } while (n > bits->bitsLeft); |
| bits->state |= state << (64 - bits->bitsLeft); |
| } |
| |
| static uint32_t avifBitsRead(avifBits * const bits, const uint32_t n) |
| { |
| if (n > bits->bitsLeft) |
| avifBitsRefill(bits, n); |
| |
| const uint64_t state = bits->state; |
| bits->bitsLeft -= n; |
| bits->state <<= n; |
| |
| return (uint32_t)(state >> (64 - n)); |
| } |
| |
| static uint32_t avifBitsReadUleb128(avifBits * bits) |
| { |
| uint64_t val = 0; |
| uint32_t more; |
| uint32_t i = 0; |
| |
| do { |
| const uint32_t v = avifBitsRead(bits, 8); |
| more = v & 0x80; |
| val |= ((uint64_t)(v & 0x7F)) << i; |
| i += 7; |
| } while (more && i < 56); |
| |
| if (val > UINT32_MAX || more) { |
| bits->error = 1; |
| return 0; |
| } |
| |
| return (uint32_t)val; |
| } |
| |
| static uint32_t avifBitsReadVLC(avifBits * const bits) |
| { |
| int numBits = 0; |
| while (!avifBitsRead(bits, 1)) |
| if (++numBits == 32) |
| return 0xFFFFFFFFU; |
| return numBits ? ((1U << numBits) - 1) + avifBitsRead(bits, numBits) : 0; |
| } |
| |
| // --------------------------------------------------------------------------- |
| // Variables in here use snake_case to self-document from the AV1 spec: |
| // |
| // https://aomediacodec.github.io/av1-spec/av1-spec.pdf |
| |
| // Originally dav1d's parse_seq_hdr() function (heavily modified) |
| static avifBool parseSequenceHeader(avifBits * bits, avifSequenceHeader * header) |
| { |
| uint32_t seq_profile = avifBitsRead(bits, 3); |
| if (seq_profile > 2) { |
| return AVIF_FALSE; |
| } |
| header->av1C.seqProfile = (uint8_t)seq_profile; |
| |
| uint32_t still_picture = avifBitsRead(bits, 1); |
| uint32_t reduced_still_picture_header = avifBitsRead(bits, 1); |
| if (reduced_still_picture_header && !still_picture) { |
| return AVIF_FALSE; |
| } |
| |
| if (reduced_still_picture_header) { |
| header->av1C.seqLevelIdx0 = (uint8_t)avifBitsRead(bits, 5); |
| header->av1C.seqTier0 = 0; |
| } else { |
| uint32_t timing_info_present_flag = avifBitsRead(bits, 1); |
| uint32_t decoder_model_info_present_flag = 0; |
| uint32_t buffer_delay_length = 0; |
| if (timing_info_present_flag) { // timing_info() |
| avifBitsRead(bits, 32); // num_units_in_display_tick |
| avifBitsRead(bits, 32); // time_scale |
| uint32_t equal_picture_interval = avifBitsRead(bits, 1); |
| if (equal_picture_interval) { |
| uint32_t num_ticks_per_picture_minus_1 = avifBitsReadVLC(bits); |
| if (num_ticks_per_picture_minus_1 == 0xFFFFFFFFU) |
| return AVIF_FALSE; |
| } |
| |
| decoder_model_info_present_flag = avifBitsRead(bits, 1); |
| if (decoder_model_info_present_flag) { // decoder_model_info() |
| buffer_delay_length = avifBitsRead(bits, 5) + 1; |
| avifBitsRead(bits, 32); // num_units_in_decoding_tick |
| avifBitsRead(bits, 10); // buffer_removal_time_length_minus_1, frame_presentation_time_length_minus_1 |
| } |
| } |
| |
| uint32_t initial_display_delay_present_flag = avifBitsRead(bits, 1); |
| uint32_t operating_points_cnt = avifBitsRead(bits, 5) + 1; |
| for (uint32_t i = 0; i < operating_points_cnt; i++) { |
| avifBitsRead(bits, 12); // operating_point_idc |
| uint32_t seq_level_idx = avifBitsRead(bits, 5); |
| if (i == 0) { |
| header->av1C.seqLevelIdx0 = (uint8_t)seq_level_idx; |
| header->av1C.seqTier0 = 0; |
| } |
| if (seq_level_idx > 7) { |
| uint32_t seq_tier = avifBitsRead(bits, 1); |
| if (i == 0) { |
| header->av1C.seqTier0 = (uint8_t)seq_tier; |
| } |
| } |
| if (decoder_model_info_present_flag) { |
| uint32_t decoder_model_present_for_this_op = avifBitsRead(bits, 1); |
| if (decoder_model_present_for_this_op) { // operating_parameters_info() |
| avifBitsRead(bits, buffer_delay_length); // decoder_buffer_delay |
| avifBitsRead(bits, buffer_delay_length); // encoder_buffer_delay |
| avifBitsRead(bits, 1); // low_delay_mode_flag |
| } |
| } |
| if (initial_display_delay_present_flag) { |
| uint32_t initial_display_delay_present_for_this_op = avifBitsRead(bits, 1); |
| if (initial_display_delay_present_for_this_op) { |
| avifBitsRead(bits, 4); // initial_display_delay_minus_1 |
| } |
| } |
| } |
| } |
| |
| uint32_t frame_width_bits = avifBitsRead(bits, 4) + 1; |
| uint32_t frame_height_bits = avifBitsRead(bits, 4) + 1; |
| header->maxWidth = avifBitsRead(bits, frame_width_bits) + 1; // max_frame_width |
| header->maxHeight = avifBitsRead(bits, frame_height_bits) + 1; // max_frame_height |
| uint32_t frame_id_numbers_present_flag = 0; |
| if (!reduced_still_picture_header) { |
| frame_id_numbers_present_flag = avifBitsRead(bits, 1); |
| } |
| if (frame_id_numbers_present_flag) { |
| avifBitsRead(bits, 7); // delta_frame_id_length_minus_2, additional_frame_id_length_minus_1 |
| } |
| |
| avifBitsRead(bits, 3); // use_128x128_superblock, enable_filter_intra, enable_intra_edge_filter |
| |
| if (!reduced_still_picture_header) { |
| avifBitsRead(bits, 4); // enable_interintra_compound, enable_masked_compound, enable_warped_motion, enable_dual_filter |
| uint32_t enable_order_hint = avifBitsRead(bits, 1); |
| if (enable_order_hint) { |
| avifBitsRead(bits, 2); // enable_jnt_comp, enable_ref_frame_mvs |
| } |
| |
| uint32_t seq_force_screen_content_tools = 0; |
| uint32_t seq_choose_screen_content_tools = avifBitsRead(bits, 1); |
| if (seq_choose_screen_content_tools) { |
| seq_force_screen_content_tools = 2; |
| } else { |
| seq_force_screen_content_tools = avifBitsRead(bits, 1); |
| } |
| if (seq_force_screen_content_tools > 0) { |
| uint32_t seq_choose_integer_mv = avifBitsRead(bits, 1); |
| if (!seq_choose_integer_mv) { |
| avifBitsRead(bits, 1); // seq_force_integer_mv |
| } |
| } |
| if (enable_order_hint) { |
| avifBitsRead(bits, 3); // order_hint_bits_minus_1 |
| } |
| } |
| |
| avifBitsRead(bits, 3); // enable_superres, enable_cdef, enable_restoration |
| |
| // color_config() |
| header->bitDepth = 8; |
| header->chromaSamplePosition = AVIF_CHROMA_SAMPLE_POSITION_UNKNOWN; |
| header->av1C.chromaSamplePosition = (uint8_t)header->chromaSamplePosition; |
| uint32_t high_bitdepth = avifBitsRead(bits, 1); |
| header->av1C.highBitdepth = (uint8_t)high_bitdepth; |
| if ((seq_profile == 2) && high_bitdepth) { |
| uint32_t twelve_bit = avifBitsRead(bits, 1); |
| header->bitDepth = twelve_bit ? 12 : 10; |
| header->av1C.twelveBit = (uint8_t)twelve_bit; |
| } else /* if (seq_profile <= 2) */ { |
| header->bitDepth = high_bitdepth ? 10 : 8; |
| header->av1C.twelveBit = 0; |
| } |
| uint32_t mono_chrome = 0; |
| if (seq_profile != 1) { |
| mono_chrome = avifBitsRead(bits, 1); |
| } |
| header->av1C.monochrome = (uint8_t)mono_chrome; |
| uint32_t color_description_present_flag = avifBitsRead(bits, 1); |
| if (color_description_present_flag) { |
| header->colorPrimaries = (avifColorPrimaries)avifBitsRead(bits, 8); // color_primaries |
| header->transferCharacteristics = (avifTransferCharacteristics)avifBitsRead(bits, 8); // transfer_characteristics |
| header->matrixCoefficients = (avifMatrixCoefficients)avifBitsRead(bits, 8); // matrix_coefficients |
| } else { |
| header->colorPrimaries = AVIF_COLOR_PRIMARIES_UNSPECIFIED; |
| header->transferCharacteristics = AVIF_TRANSFER_CHARACTERISTICS_UNSPECIFIED; |
| header->matrixCoefficients = AVIF_MATRIX_COEFFICIENTS_UNSPECIFIED; |
| } |
| if (mono_chrome) { |
| header->range = avifBitsRead(bits, 1) ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; // color_range |
| header->av1C.chromaSubsamplingX = 1; |
| header->av1C.chromaSubsamplingY = 1; |
| header->yuvFormat = AVIF_PIXEL_FORMAT_YUV400; |
| } else if (header->colorPrimaries == AVIF_COLOR_PRIMARIES_BT709 && |
| header->transferCharacteristics == AVIF_TRANSFER_CHARACTERISTICS_SRGB && |
| header->matrixCoefficients == AVIF_MATRIX_COEFFICIENTS_IDENTITY) { |
| header->range = AVIF_RANGE_FULL; |
| header->av1C.chromaSubsamplingX = 0; |
| header->av1C.chromaSubsamplingY = 0; |
| header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; |
| } else { |
| uint32_t subsampling_x = 0; |
| uint32_t subsampling_y = 0; |
| header->range = avifBitsRead(bits, 1) ? AVIF_RANGE_FULL : AVIF_RANGE_LIMITED; // color_range |
| switch (seq_profile) { |
| case 0: |
| subsampling_x = 1; |
| subsampling_y = 1; |
| header->yuvFormat = AVIF_PIXEL_FORMAT_YUV420; |
| break; |
| case 1: |
| subsampling_x = 0; |
| subsampling_y = 0; |
| header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; |
| break; |
| case 2: |
| if (header->bitDepth == 12) { |
| subsampling_x = avifBitsRead(bits, 1); |
| if (subsampling_x) { |
| subsampling_y = avifBitsRead(bits, 1); |
| } |
| } else { |
| subsampling_x = 1; |
| subsampling_y = 0; |
| } |
| if (subsampling_x) { |
| header->yuvFormat = subsampling_y ? AVIF_PIXEL_FORMAT_YUV420 : AVIF_PIXEL_FORMAT_YUV422; |
| } else { |
| header->yuvFormat = AVIF_PIXEL_FORMAT_YUV444; |
| } |
| break; |
| } |
| |
| if (subsampling_x && subsampling_y) { |
| header->chromaSamplePosition = (avifChromaSamplePosition)avifBitsRead(bits, 2); // chroma_sample_position |
| header->av1C.chromaSamplePosition = (uint8_t)header->chromaSamplePosition; |
| } |
| header->av1C.chromaSubsamplingX = (uint8_t)subsampling_x; |
| header->av1C.chromaSubsamplingY = (uint8_t)subsampling_y; |
| } |
| |
| if (!mono_chrome) { |
| avifBitsRead(bits, 1); // separate_uv_delta_q |
| } |
| avifBitsRead(bits, 1); // film_grain_params_present |
| |
| return !bits->error; |
| } |
| |
| avifBool avifSequenceHeaderParse(avifSequenceHeader * header, const avifROData * sample) |
| { |
| avifROData obus = *sample; |
| |
| // Find the sequence header OBU |
| while (obus.size > 0) { |
| avifBits bits; |
| avifBitsInit(&bits, obus.data, obus.size); |
| |
| // obu_header() |
| avifBitsRead(&bits, 1); // obu_forbidden_bit |
| const uint32_t obu_type = avifBitsRead(&bits, 4); |
| const uint32_t obu_extension_flag = avifBitsRead(&bits, 1); |
| const uint32_t obu_has_size_field = avifBitsRead(&bits, 1); |
| avifBitsRead(&bits, 1); // obu_reserved_1bit |
| |
| if (obu_extension_flag) { // obu_extension_header() |
| avifBitsRead(&bits, 8); // temporal_id, spatial_id, extension_header_reserved_3bits |
| } |
| |
| uint32_t obu_size = 0; |
| if (obu_has_size_field) |
| obu_size = avifBitsReadUleb128(&bits); |
| else |
| obu_size = (int)obus.size - 1 - obu_extension_flag; |
| |
| if (bits.error) { |
| return AVIF_FALSE; |
| } |
| |
| const uint32_t init_bit_pos = avifBitsReadPos(&bits); |
| const uint32_t init_byte_pos = init_bit_pos >> 3; |
| if (obu_size > obus.size - init_byte_pos) |
| return AVIF_FALSE; |
| |
| if (obu_type == 1) { // Sequence Header |
| return parseSequenceHeader(&bits, header); |
| } |
| |
| // Skip this OBU |
| obus.data += (size_t)obu_size + init_byte_pos; |
| obus.size -= (size_t)obu_size + init_byte_pos; |
| } |
| return AVIF_FALSE; |
| } |
