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/avassert.h"
  23 #include "libavutil/mem.h"
  24 #include "libavcodec/av1.h"
  25 #include "libavcodec/av1_parse.h"
  26 #include "libavcodec/profiles.h"
  27 #include "libavcodec/put_bits.h"
  28 #include "av1.h"
  29 #include "avio.h"
  30 #include "avio_internal.h"
  31
  32 static int av1_filter_obus(AVIOContext *pb, const uint8_t *buf,
  33                            int size, int *offset)
  34 {
  35     const uint8_t *start = buf, *end = buf + size;
  36     int64_t obu_size;
  37     int off, start_pos, type, temporal_id, spatial_id;
  38     enum {
  39         START_NOT_FOUND,
  40         START_FOUND,
  41         END_FOUND,
  42         OFFSET_IMPOSSIBLE,
  43     } state = START_NOT_FOUND;
  44
  45     off = size = 0;
  46     while (buf < end) {
  47         int len = parse_obu_header(buf, end - buf, &obu_size, &start_pos,
  48                                    &type, &temporal_id, &spatial_id);
  49         if (len < 0)
  50             return len;
  51
  52         switch (type) {
  53         case AV1_OBU_TEMPORAL_DELIMITER:
  54         case AV1_OBU_REDUNDANT_FRAME_HEADER:
  55         case AV1_OBU_TILE_LIST:
  56         case AV1_OBU_PADDING:
  57             if (state == START_FOUND)
  58                 state = END_FOUND;
  59             break;
  60         default:
  61             if (state == START_NOT_FOUND) {
  62                 off   = buf - start;
  63                 state = START_FOUND;
  64             } else if (state == END_FOUND) {
  65                 state = OFFSET_IMPOSSIBLE;
  66             }
  67             if (pb)
  68                 avio_write(pb, buf, len);
  69             size += len;
  70             break;
  71         }
  72         buf += len;
  73     }
  74
  75     if (offset)
  76         *offset = state != OFFSET_IMPOSSIBLE ? off : -1;
  77
  78     return size;
  79 }
  80
  81 int ff_av1_filter_obus(AVIOContext *pb, const uint8_t *buf, int size)
  82 {
  83     return av1_filter_obus(pb, buf, size, NULL);
  84 }
  85
  86 int ff_av1_filter_obus_buf(const uint8_t *in, uint8_t **out,
  87                            int *size, int *offset)
  88 {
  89     AVIOContext pb;
  90     uint8_t *buf;
  91     int len, off, ret;
  92
  93     len = ret = av1_filter_obus(NULL, in, *size, &off);
  94     if (ret < 0) {
  95         return ret;
  96     }
  97     if (off >= 0) {
  98         *out    = (uint8_t *)in;
  99         *size   = len;
 100         *offset = off;
 101
 102         return 0;
 103     }
 104
 105     buf = av_malloc(len + AV_INPUT_BUFFER_PADDING_SIZE);
 106     if (!buf)
 107         return AVERROR(ENOMEM);
 108
 109     ffio_init_context(&pb, buf, len, 1, NULL, NULL, NULL, NULL);
 110
 111     ret = av1_filter_obus(&pb, in, *size, NULL);
 112     av_assert1(ret == len);
 113
 114     memset(buf + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 115
 116     *out  = buf;
 117     *size = len;
 118     *offset = 0;
 119
 120     return 0;
 121 }
 122
 123 static inline void uvlc(GetBitContext *gb)
 124 {
 125     int leading_zeros = 0;
 126
 127     while (get_bits_left(gb)) {
 128         if (get_bits1(gb))
 129             break;
 130         leading_zeros++;
 131     }
 132
 133     if (leading_zeros >= 32)
 134         return;
 135
 136     skip_bits_long(gb, leading_zeros);
 137 }
 138
 139 static int parse_color_config(AV1SequenceParameters *seq_params, GetBitContext *gb)
 140 {
 141     int twelve_bit = 0;
 142     int high_bitdepth = get_bits1(gb);
 143     if (seq_params->profile == FF_PROFILE_AV1_PROFESSIONAL && high_bitdepth)
 144         twelve_bit = get_bits1(gb);
 145
 146     seq_params->bitdepth = 8 + (high_bitdepth * 2) + (twelve_bit * 2);
 147
 148     if (seq_params->profile == FF_PROFILE_AV1_HIGH)
 149         seq_params->monochrome = 0;
 150     else
 151         seq_params->monochrome = get_bits1(gb);
 152
 153     seq_params->color_description_present_flag = get_bits1(gb);
 154     if (seq_params->color_description_present_flag) {
 155         seq_params->color_primaries          = get_bits(gb, 8);
 156         seq_params->transfer_characteristics = get_bits(gb, 8);
 157         seq_params->matrix_coefficients      = get_bits(gb, 8);
 158     } else {
 159         seq_params->color_primaries          = AVCOL_PRI_UNSPECIFIED;
 160         seq_params->transfer_characteristics = AVCOL_TRC_UNSPECIFIED;
 161         seq_params->matrix_coefficients      = AVCOL_SPC_UNSPECIFIED;
 162     }
 163
 164     if (seq_params->monochrome) {
 165         seq_params->color_range = get_bits1(gb);
 166         seq_params->chroma_subsampling_x = 1;
 167         seq_params->chroma_subsampling_y = 1;
 168         seq_params->chroma_sample_position = 0;
 169         return 0;
 170     } else if (seq_params->color_primaries          == AVCOL_PRI_BT709 &&
 171                seq_params->transfer_characteristics == AVCOL_TRC_IEC61966_2_1 &&
 172                seq_params->matrix_coefficients      == AVCOL_SPC_RGB) {
 173         seq_params->chroma_subsampling_x = 0;
 174         seq_params->chroma_subsampling_y = 0;
 175     } else {
 176         seq_params->color_range = get_bits1(gb);
 177
 178         if (seq_params->profile == FF_PROFILE_AV1_MAIN) {
 179             seq_params->chroma_subsampling_x = 1;
 180             seq_params->chroma_subsampling_y = 1;
 181         } else if (seq_params->profile == FF_PROFILE_AV1_HIGH) {
 182             seq_params->chroma_subsampling_x = 0;
 183             seq_params->chroma_subsampling_y = 0;
 184         } else {
 185             if (twelve_bit) {
 186                 seq_params->chroma_subsampling_x = get_bits1(gb);
 187                 if (seq_params->chroma_subsampling_x)
 188                     seq_params->chroma_subsampling_y = get_bits1(gb);
 189                 else
 190                     seq_params->chroma_subsampling_y = 0;
 191             } else {
 192                 seq_params->chroma_subsampling_x = 1;
 193                 seq_params->chroma_subsampling_y = 0;
 194             }
 195         }
 196         if (seq_params->chroma_subsampling_x && seq_params->chroma_subsampling_y)
 197             seq_params->chroma_sample_position = get_bits(gb, 2);
 198     }
 199
 200     skip_bits1(gb); // separate_uv_delta_q
 201
 202     return 0;
 203 }
 204
 205 static int parse_sequence_header(AV1SequenceParameters *seq_params, const uint8_t *buf, int size)
 206 {
 207     GetBitContext gb;
 208     int reduced_still_picture_header;
 209     int frame_width_bits_minus_1, frame_height_bits_minus_1;
 210     int size_bits, ret;
 211
 212     size_bits = get_obu_bit_length(buf, size, AV1_OBU_SEQUENCE_HEADER);
 213     if (size_bits < 0)
 214         return size_bits;
 215
 216     ret = init_get_bits(&gb, buf, size_bits);
 217     if (ret < 0)
 218         return ret;
 219
 220     memset(seq_params, 0, sizeof(*seq_params));
 221
 222     seq_params->profile = get_bits(&gb, 3);
 223
 224     skip_bits1(&gb); // still_picture
 225     reduced_still_picture_header = get_bits1(&gb);
 226
 227     if (reduced_still_picture_header) {
 228         seq_params->level = get_bits(&gb, 5);
 229         seq_params->tier = 0;
 230     } else {
 231         int initial_display_delay_present_flag, operating_points_cnt_minus_1;
 232         int decoder_model_info_present_flag, buffer_delay_length_minus_1;
 233
 234         if (get_bits1(&gb)) { // timing_info_present_flag
 235             skip_bits_long(&gb, 32); // num_units_in_display_tick
 236             skip_bits_long(&gb, 32); // time_scale
 237
 238             if (get_bits1(&gb)) // equal_picture_interval
 239                 uvlc(&gb); // num_ticks_per_picture_minus_1
 240
 241             decoder_model_info_present_flag = get_bits1(&gb);
 242             if (decoder_model_info_present_flag) {
 243                 buffer_delay_length_minus_1 = get_bits(&gb, 5);
 244                 skip_bits_long(&gb, 32); // num_units_in_decoding_tick
 245                 skip_bits(&gb, 10); // buffer_removal_time_length_minus_1 (5)
 246                                     // frame_presentation_time_length_minus_1 (5)
 247             }
 248         } else
 249             decoder_model_info_present_flag = 0;
 250
 251         initial_display_delay_present_flag = get_bits1(&gb);
 252
 253         operating_points_cnt_minus_1 = get_bits(&gb, 5);
 254         for (int i = 0; i <= operating_points_cnt_minus_1; i++) {
 255             int seq_level_idx, seq_tier;
 256
 257             skip_bits(&gb, 12); // operating_point_idc
 258             seq_level_idx = get_bits(&gb, 5);
 259
 260             if (seq_level_idx > 7)
 261                 seq_tier = get_bits1(&gb);
 262             else
 263                 seq_tier = 0;
 264
 265             if (decoder_model_info_present_flag) {
 266                 if (get_bits1(&gb)) { // decoder_model_present_for_this_op
 267                     skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // decoder_buffer_delay
 268                     skip_bits_long(&gb, buffer_delay_length_minus_1 + 1); // encoder_buffer_delay
 269                     skip_bits1(&gb); // low_delay_mode_flag
 270                 }
 271             }
 272
 273             if (initial_display_delay_present_flag) {
 274                 if (get_bits1(&gb)) // initial_display_delay_present_for_this_op
 275                     skip_bits(&gb, 4); // initial_display_delay_minus_1
 276             }
 277
 278             if (i == 0) {
 279                seq_params->level = seq_level_idx;
 280                seq_params->tier = seq_tier;
 281             }
 282         }
 283     }
 284
 285     frame_width_bits_minus_1  = get_bits(&gb, 4);
 286     frame_height_bits_minus_1 = get_bits(&gb, 4);
 287
 288     skip_bits(&gb, frame_width_bits_minus_1 + 1); // max_frame_width_minus_1
 289     skip_bits(&gb, frame_height_bits_minus_1 + 1); // max_frame_height_minus_1
 290
 291     if (!reduced_still_picture_header) {
 292         if (get_bits1(&gb)) // frame_id_numbers_present_flag
 293             skip_bits(&gb, 7); // delta_frame_id_length_minus_2 (4), additional_frame_id_length_minus_1 (3)
 294     }
 295
 296     skip_bits(&gb, 3); // use_128x128_superblock (1), enable_filter_intra (1), enable_intra_edge_filter (1)
 297
 298     if (!reduced_still_picture_header) {
 299         int enable_order_hint, seq_force_screen_content_tools;
 300
 301         skip_bits(&gb, 4); // enable_interintra_compound (1), enable_masked_compound (1)
 302                            // enable_warped_motion (1), enable_dual_filter (1)
 303
 304         enable_order_hint = get_bits1(&gb);
 305         if (enable_order_hint)
 306             skip_bits(&gb, 2); // enable_jnt_comp (1), enable_ref_frame_mvs (1)
 307
 308         if (get_bits1(&gb)) // seq_choose_screen_content_tools
 309             seq_force_screen_content_tools = 2;
 310         else
 311             seq_force_screen_content_tools = get_bits1(&gb);
 312
 313         if (seq_force_screen_content_tools) {
 314             if (!get_bits1(&gb)) // seq_choose_integer_mv
 315                 skip_bits1(&gb); // seq_force_integer_mv
 316         }
 317
 318         if (enable_order_hint)
 319             skip_bits(&gb, 3); // order_hint_bits_minus_1
 320     }
 321
 322     skip_bits(&gb, 3); // enable_superres (1), enable_cdef (1), enable_restoration (1)
 323
 324     parse_color_config(seq_params, &gb);
 325
 326     skip_bits1(&gb); // film_grain_params_present
 327
 328     if (get_bits_left(&gb))
 329         return AVERROR_INVALIDDATA;
 330
 331     return 0;
 332 }
 333
 334 int ff_av1_parse_seq_header(AV1SequenceParameters *seq, const uint8_t *buf, int size)
 335 {
 336     int64_t obu_size;
 337     int start_pos, type, temporal_id, spatial_id;
 338
 339     if (size <= 0)
 340         return AVERROR_INVALIDDATA;
 341
 342     while (size > 0) {
 343         int len = parse_obu_header(buf, size, &obu_size, &start_pos,
 344                                    &type, &temporal_id, &spatial_id);
 345         if (len < 0)
 346             return len;
 347
 348         switch (type) {
 349         case AV1_OBU_SEQUENCE_HEADER:
 350             if (!obu_size)
 351                 return AVERROR_INVALIDDATA;
 352
 353             return parse_sequence_header(seq, buf + start_pos, obu_size);
 354         default:
 355             break;
 356         }
 357         size -= len;
 358         buf  += len;
 359     }
 360
 361     return AVERROR_INVALIDDATA;
 362 }
 363
 364 int ff_isom_write_av1c(AVIOContext *pb, const uint8_t *buf, int size)
 365 {
 366     AVIOContext *meta_pb;
 367     AV1SequenceParameters seq_params;
 368     PutBitContext pbc;
 369     uint8_t header[4], *meta;
 370     const uint8_t *seq;
 371     int64_t obu_size;
 372     int start_pos, type, temporal_id, spatial_id;
 373     int ret, nb_seq = 0, seq_size, meta_size;
 374
 375     if (size <= 0)
 376         return AVERROR_INVALIDDATA;
 377
 378     if (buf[0] & 0x80) {
 379         // first bit is nonzero, the passed data does not consist purely of
 380         // OBUs. Expect that the data is already in AV1CodecConfigurationRecord
 381         // format.
 382         int config_record_version = buf[0] & 0x7f;
 383         if (config_record_version != 1 || size < 4) {
 384             return AVERROR_INVALIDDATA;
 385         }
 386
 387         avio_write(pb, buf, size);
 388
 389         return 0;
 390     }
 391
 392     ret = avio_open_dyn_buf(&meta_pb);
 393     if (ret < 0)
 394         return ret;
 395
 396     while (size > 0) {
 397         int len = parse_obu_header(buf, size, &obu_size, &start_pos,
 398                                    &type, &temporal_id, &spatial_id);
 399         if (len < 0) {
 400             ret = len;
 401             goto fail;
 402         }
 403
 404         switch (type) {
 405         case AV1_OBU_SEQUENCE_HEADER:
 406             nb_seq++;
 407             if (!obu_size || nb_seq > 1) {
 408                 ret = AVERROR_INVALIDDATA;
 409                 goto fail;
 410             }
 411             ret = parse_sequence_header(&seq_params, buf + start_pos, obu_size);
 412             if (ret < 0)
 413                 goto fail;
 414
 415             seq      = buf;
 416             seq_size = len;
 417             break;
 418         case AV1_OBU_METADATA:
 419             if (!obu_size) {
 420                 ret = AVERROR_INVALIDDATA;
 421                 goto fail;
 422             }
 423             avio_write(meta_pb, buf, len);
 424             break;
 425         default:
 426             break;
 427         }
 428         size -= len;
 429         buf  += len;
 430     }
 431
 432     if (!nb_seq) {
 433         ret = AVERROR_INVALIDDATA;
 434         goto fail;
 435     }
 436
 437     init_put_bits(&pbc, header, sizeof(header));
 438
 439     put_bits(&pbc, 1, 1); // marker
 440     put_bits(&pbc, 7, 1); // version
 441     put_bits(&pbc, 3, seq_params.profile);
 442     put_bits(&pbc, 5, seq_params.level);
 443     put_bits(&pbc, 1, seq_params.tier);
 444     put_bits(&pbc, 1, seq_params.bitdepth > 8);
 445     put_bits(&pbc, 1, seq_params.bitdepth == 12);
 446     put_bits(&pbc, 1, seq_params.monochrome);
 447     put_bits(&pbc, 1, seq_params.chroma_subsampling_x);
 448     put_bits(&pbc, 1, seq_params.chroma_subsampling_y);
 449     put_bits(&pbc, 2, seq_params.chroma_sample_position);
 450     put_bits(&pbc, 8, 0); // padding
 451     flush_put_bits(&pbc);
 452
 453     avio_write(pb, header, sizeof(header));
 454     avio_write(pb, seq, seq_size);
 455
 456     meta_size = avio_get_dyn_buf(meta_pb, &meta);
 457     if (meta_size)
 458         avio_write(pb, meta, meta_size);
 459
 460 fail:
 461     ffio_free_dyn_buf(&meta_pb);
 462
 463     return ret;
 464 }