git.sesse.net Git - ffmpeg/blob - libavformat/av1.c

   1 /*
   2  * AV1 helper functions for muxers
   3  * Copyright (c) 2018 James Almer <jamrial@gmail.com>
   4  *
   5  * This file is part of FFmpeg.
   6  *
   7  * FFmpeg is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * FFmpeg is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with FFmpeg; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20  */
  21
  22 #include "libavutil/mem.h"
  23 #include "libavcodec/av1.h"
  24 #include "libavcodec/av1_parse.h"
  25 #include "libavcodec/profiles.h"
  26 #include "libavcodec/put_bits.h"
  27 #include "av1.h"
  28 #include "avio.h"
  29 #include "avio_internal.h"
  30
  31 int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
  32 {
  33     const uint8_t *end = buf + size;
  34     int64_t obu_size;
  35     int start_pos, type, temporal_id, spatial_id;
  36
  37     size = 0;
  38     while (buf < end) {
  39         int len = parse_obu_header(buf, end - buf, &obu_size, &start_pos,
  40                                    &type, &temporal_id, &spatial_id);
  41         if (len < 0)
  42             return len;
  43
  44         switch (type) {
  45         case AV1_OBU_TEMPORAL_DELIMITER:
  46         case AV1_OBU_REDUNDANT_FRAME_HEADER:
  47         case AV1_OBU_TILE_LIST:
  48         case AV1_OBU_PADDING:
  49             break;
  50         default:
  51             avio_write(pb, buf, len);
  52             size += len;
  53             break;
  54         }
  55         buf += len;
  56     }
  57
  58     return size;
  59 }
  60
  61 int ff_av1_filter_obus_buf(const uint8_t *buf, uint8_t **out, int *size)
  62 {
  63     AVIOContext *pb;
  64     int ret;
  65
  66     ret = avio_open_dyn_buf(&pb);
  67     if (ret < 0)
  68         return ret;
  69
  70     ret = ff_av1_filter_obus(pb, buf, *size);
  71     if (ret < 0) {
  72         ffio_free_dyn_buf(&pb);
  73         return ret;
  74     }
  75
  76     av_freep(out);
  77     *size = avio_close_dyn_buf(pb, out);
  78
  79     return ret;
  80 }
  81
  82 static inline void uvlc(GetBitContext *gb)
  83 {
  84     int leading_zeros = 0;
  85
  86     while (get_bits_left(gb)) {
  87         if (get_bits1(gb))
  88             break;
  89         leading_zeros++;
  90     }
  91
  92     if (leading_zeros >= 32)
  93         return;
  94
  95     skip_bits_long(gb, leading_zeros);
  96 }
  97
  98 static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)
  99 {
 100     int twelve_bit = 0;
 101     int high_bitdepth = get_bits1(gb);
 102     if (seq_params->profile == FF_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
 103         twelve_bit = get_bits1(gb);
 104
 105     seq_params->bitdepth = 8 + (high_bitdepth * 2) + (twelve_bit * 2);
 106
 107     if (seq_params->profile == FF_PROFILE_AV1_HIGH)
 108         seq_params->monochrome = 0;
 109     else
 110         seq_params->monochrome = get_bits1(gb);
 111
 112     seq_params->color_description_present_flag = get_bits1(gb);
 113     if (seq_params->color_description_present_flag) {
 114         seq_params->color_primaries          = get_bits(gb, 8);
 115         seq_params->transfer_characteristics = get_bits(gb, 8);
 116         seq_params->matrix_coefficients      = get_bits(gb, 8);
 117     } else {
 118         seq_params->color_primaries          = AVCOL_PRI_UNSPECIFIED;
 119         seq_params->transfer_characteristics = AVCOL_TRC_UNSPECIFIED;
 120         seq_params->matrix_coefficients      = AVCOL_SPC_UNSPECIFIED;
 121     }
 122
 123     if (seq_params->monochrome) {
 124         seq_params->color_range = get_bits1(gb);
 125         seq_params->chroma_subsampling_x = 1;
 126         seq_params->chroma_subsampling_y = 1;
 127         seq_params->chroma_sample_position = 0;
 128         return 0;
 129     } else if (seq_params->color_primaries          == AVCOL_PRI_BT709 &&
 130                seq_params->transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
 131                seq_params->matrix_coefficients      == AVCOL_SPC_RGB) {
 132         seq_params->chroma_subsampling_x = 0;
 133         seq_params->chroma_subsampling_y = 0;
 134     } else {
 135         seq_params->color_range = get_bits1(gb);
 136
 137         if (seq_params->profile == FF_PROFILE_AV1_MAIN) {
 138             seq_params->chroma_subsampling_x = 1;
 139             seq_params->chroma_subsampling_y = 1;
 140         } else if (seq_params->profile == FF_PROFILE_AV1_HIGH) {
 141             seq_params->chroma_subsampling_x = 0;
 142             seq_params->chroma_subsampling_y = 0;
 143         } else {
 144             if (twelve_bit) {
 145                 seq_params->chroma_subsampling_x = get_bits1(gb);
 146                 if (seq_params->chroma_subsampling_x)
 147                     seq_params->chroma_subsampling_y = get_bits1(gb);
 148                 else
 149                     seq_params->chroma_subsampling_y = 0;
 150             } else {
 151                 seq_params->chroma_subsampling_x = 1;
 152                 seq_params->chroma_subsampling_y = 0;
 153             }
 154         }
 155         if (seq_params->chroma_subsampling_x && seq_params->chroma_subsampling_y)
 156             seq_params->chroma_sample_position = get_bits(gb, 2);
 157     }
 158
 159     skip_bits1(gb); // separate_uv_delta_q
 160
 161     return 0;
 162 }
 163
 164 static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
 165 {
 166     GetBitContext gb;
 167     int reduced_still_picture_header;
 168     int frame_width_bits_minus_1, frame_height_bits_minus_1;
 169     int size_bits, ret;
 170
 171     size_bits = get_obu_bit_length(buf, size, AV1_OBU_SEQUENCE_HEADER);
 172     if (size_bits < 0)
 173         return size_bits;
 174
 175     ret = init_get_bits(&gb, buf, size_bits);
 176     if (ret < 0)
 177         return ret;
 178
 179     memset(seq_params, 0, sizeof(*seq_params));
 180
 181     seq_params->profile = get_bits(&gb, 3);
 182
 183     skip_bits1(&gb); // still_picture
 184     reduced_still_picture_header = get_bits1(&gb);
 185
 186     if (reduced_still_picture_header) {
 187         seq_params->level = get_bits(&gb, 5);
 188         seq_params->tier = 0;
 189     } else {
 190         int initial_display_delay_present_flag, operating_points_cnt_minus_1;
 191         int decoder_model_info_present_flag, buffer_delay_length_minus_1;
 192
 193         if (get_bits1(&gb)) { // timing_info_present_flag
 194             skip_bits_long(&gb, 32); // num_units_in_display_tick
 195             skip_bits_long(&gb, 32); // time_scale
 196
 197             if (get_bits1(&gb)) // equal_picture_interval
 198                 uvlc(&gb); // num_ticks_per_picture_minus_1
 199
 200             decoder_model_info_present_flag = get_bits1(&gb);
 201             if (decoder_model_info_present_flag) {
 202                 buffer_delay_length_minus_1 = get_bits(&gb, 5);
 203                 skip_bits_long(&gb, 32); // num_units_in_decoding_tick
 204                 skip_bits(&gb, 10); // buffer_removal_time_length_minus_1 (5)
 205                                     // frame_presentation_time_length_minus_1 (5)
 206             }
 207         } else
 208             decoder_model_info_present_flag = 0;
 209
 210         initial_display_delay_present_flag = get_bits1(&gb);
 211
 212         operating_points_cnt_minus_1 = get_bits(&gb, 5);
 213         for (int i = 0; i <= operating_points_cnt_minus_1; i++) {
 214             int seq_level_idx, seq_tier;
 215
 216             skip_bits(&gb, 12); // operating_point_idc
 217             seq_level_idx = get_bits(&gb, 5);
 218
 219             if (seq_level_idx > 7)
 220                 seq_tier = get_bits1(&gb);
 221             else
 222                 seq_tier = 0;
 223
 224             if (decoder_model_info_present_flag) {
 225                 if (get_bits1(&gb)) { // decoder_model_present_for_this_op
 226                     skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // decoder_buffer_delay
 227                     skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // encoder_buffer_delay
 228                     skip_bits1(&gb); // low_delay_mode_flag
 229                 }
 230             }
 231
 232             if (initial_display_delay_present_flag) {
 233                 if (get_bits1(&gb)) // initial_display_delay_present_for_this_op
 234                     skip_bits(&gb, 4); // initial_display_delay_minus_1
 235             }
 236
 237             if (i == 0) {
 238                seq_params->level = seq_level_idx;
 239                seq_params->tier = seq_tier;
 240             }
 241         }
 242     }
 243
 244     frame_width_bits_minus_1  = get_bits(&gb, 4);
 245     frame_height_bits_minus_1 = get_bits(&gb, 4);
 246
 247     skip_bits(&gb, frame_width_bits_minus_1 + 1); // max_frame_width_minus_1
 248     skip_bits(&gb, frame_height_bits_minus_1 + 1); // max_frame_height_minus_1
 249
 250     if (!reduced_still_picture_header) {
 251         if (get_bits1(&gb)) // frame_id_numbers_present_flag
 252             skip_bits(&gb, 7); // delta_frame_id_length_minus_2 (4), additional_frame_id_length_minus_1 (3)
 253     }
 254
 255     skip_bits(&gb, 3); // use_128x128_superblock (1), enable_filter_intra (1), enable_intra_edge_filter (1)
 256
 257     if (!reduced_still_picture_header) {
 258         int enable_order_hint, seq_force_screen_content_tools;
 259
 260         skip_bits(&gb, 4); // enable_interintra_compound (1), enable_masked_compound (1)
 261                            // enable_warped_motion (1), enable_dual_filter (1)
 262
 263         enable_order_hint = get_bits1(&gb);
 264         if (enable_order_hint)
 265             skip_bits(&gb, 2); // enable_jnt_comp (1), enable_ref_frame_mvs (1)
 266
 267         if (get_bits1(&gb)) // seq_choose_screen_content_tools
 268             seq_force_screen_content_tools = 2;
 269         else
 270             seq_force_screen_content_tools = get_bits1(&gb);
 271
 272         if (seq_force_screen_content_tools) {
 273             if (!get_bits1(&gb)) // seq_choose_integer_mv
 274                 skip_bits1(&gb); // seq_force_integer_mv
 275         }
 276
 277         if (enable_order_hint)
 278             skip_bits(&gb, 3); // order_hint_bits_minus_1
 279     }
 280
 281     skip_bits(&gb, 3); // enable_superres (1), enable_cdef (1), enable_restoration (1)
 282
 283     parse_color_config(seq_params, &gb);
 284
 285     skip_bits1(&gb); // film_grain_params_present
 286
 287     if (get_bits_left(&gb))
 288         return AVERROR_INVALIDDATA;
 289
 290     return 0;
 291 }
 292
 293 int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
 294 {
 295     int64_t obu_size;
 296     int start_pos, type, temporal_id, spatial_id;
 297
 298     if (size <= 0)
 299         return AVERROR_INVALIDDATA;
 300
 301     while (size > 0) {
 302         int len = parse_obu_header(buf, size, &obu_size, &start_pos,
 303                                    &type, &temporal_id, &spatial_id);
 304         if (len < 0)
 305             return len;
 306
 307         switch (type) {
 308         case AV1_OBU_SEQUENCE_HEADER:
 309             if (!obu_size)
 310                 return AVERROR_INVALIDDATA;
 311
 312             return parse_sequence_header(seq, buf + start_pos, obu_size);
 313         default:
 314             break;
 315         }
 316         size -= len;
 317         buf  += len;
 318     }
 319
 320     return AVERROR_INVALIDDATA;
 321 }
 322
 323 int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
 324 {
 325     AVIOContext *seq_pb = NULL, *meta_pb = NULL;
 326     AV1SequenceParameters seq_params;
 327     PutBitContext pbc;
 328     uint8_t header[4];
 329     uint8_t *seq, *meta;
 330     int64_t obu_size;
 331     int start_pos, type, temporal_id, spatial_id;
 332     int ret, nb_seq = 0, seq_size, meta_size;
 333
 334     if (size <= 0)
 335         return AVERROR_INVALIDDATA;
 336
 337     ret = avio_open_dyn_buf(&seq_pb);
 338     if (ret < 0)
 339         return ret;
 340     ret = avio_open_dyn_buf(&meta_pb);
 341     if (ret < 0)
 342         goto fail;
 343
 344     while (size > 0) {
 345         int len = parse_obu_header(buf, size, &obu_size, &start_pos,
 346                                    &type, &temporal_id, &spatial_id);
 347         if (len < 0) {
 348             ret = len;
 349             goto fail;
 350         }
 351
 352         switch (type) {
 353         case AV1_OBU_SEQUENCE_HEADER:
 354             nb_seq++;
 355             if (!obu_size || nb_seq > 1) {
 356                 ret = AVERROR_INVALIDDATA;
 357                 goto fail;
 358             }
 359             ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);
 360             if (ret < 0)
 361                 goto fail;
 362
 363             avio_write(seq_pb, buf, len);
 364             break;
 365         case AV1_OBU_METADATA:
 366             if (!obu_size) {
 367                 ret = AVERROR_INVALIDDATA;
 368                 goto fail;
 369             }
 370             avio_write(meta_pb, buf, len);
 371             break;
 372         default:
 373             break;
 374         }
 375         size -= len;
 376         buf  += len;
 377     }
 378
 379     seq_size  = avio_get_dyn_buf(seq_pb, &seq);
 380     if (!seq_size) {
 381         ret = AVERROR_INVALIDDATA;
 382         goto fail;
 383     }
 384
 385     init_put_bits(&pbc, header, sizeof(header));
 386
 387     put_bits(&pbc, 1, 1); // marker
 388     put_bits(&pbc, 7, 1); // version
 389     put_bits(&pbc, 3, seq_params.profile);
 390     put_bits(&pbc, 5, seq_params.level);
 391     put_bits(&pbc, 1, seq_params.tier);
 392     put_bits(&pbc, 1, seq_params.bitdepth > 8);
 393     put_bits(&pbc, 1, seq_params.bitdepth == 12);
 394     put_bits(&pbc, 1, seq_params.monochrome);
 395     put_bits(&pbc, 1, seq_params.chroma_subsampling_x);
 396     put_bits(&pbc, 1, seq_params.chroma_subsampling_y);
 397     put_bits(&pbc, 2, seq_params.chroma_sample_position);
 398     put_bits(&pbc, 8, 0); // padding
 399     flush_put_bits(&pbc);
 400
 401     avio_write(pb, header, sizeof(header));
 402     avio_write(pb, seq, seq_size);
 403
 404     meta_size = avio_get_dyn_buf(meta_pb, &meta);
 405     if (meta_size)
 406         avio_write(pb, meta, meta_size);
 407
 408 fail:
 409     ffio_free_dyn_buf(&seq_pb);
 410     ffio_free_dyn_buf(&meta_pb);
 411
 412     return ret;
 413 }