git.sesse.net Git - ffmpeg/blob - libavcodec/h264_parse.c

   1 /*
   2  * This file is part of FFmpeg.
   3  *
   4  * FFmpeg is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * FFmpeg is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with FFmpeg; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  17  */
  18
  19 #include "bytestream.h"
  20 #include "get_bits.h"
  21 #include "golomb.h"
  22 #include "h264.h"
  23 #include "h264_parse.h"
  24
  25 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
  26                               const int *ref_count, int slice_type_nos,
  27                               H264PredWeightTable *pwt, void *logctx)
  28 {
  29     int list, i;
  30     int luma_def, chroma_def;
  31
  32     pwt->use_weight             = 0;
  33     pwt->use_weight_chroma      = 0;
  34     pwt->luma_log2_weight_denom = get_ue_golomb(gb);
  35     if (sps->chroma_format_idc)
  36         pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
  37
  38     if (pwt->luma_log2_weight_denom > 7U) {
  39         av_log(logctx, AV_LOG_ERROR, "luma_log2_weight_denom %d is out of range\n", pwt->luma_log2_weight_denom);
  40         pwt->luma_log2_weight_denom = 0;
  41     }
  42     if (pwt->chroma_log2_weight_denom > 7U) {
  43         av_log(logctx, AV_LOG_ERROR, "chroma_log2_weight_denom %d is out of range\n", pwt->chroma_log2_weight_denom);
  44         pwt->chroma_log2_weight_denom = 0;
  45     }
  46
  47     luma_def   = 1 << pwt->luma_log2_weight_denom;
  48     chroma_def = 1 << pwt->chroma_log2_weight_denom;
  49
  50     for (list = 0; list < 2; list++) {
  51         pwt->luma_weight_flag[list]   = 0;
  52         pwt->chroma_weight_flag[list] = 0;
  53         for (i = 0; i < ref_count[list]; i++) {
  54             int luma_weight_flag, chroma_weight_flag;
  55
  56             luma_weight_flag = get_bits1(gb);
  57             if (luma_weight_flag) {
  58                 pwt->luma_weight[i][list][0] = get_se_golomb(gb);
  59                 pwt->luma_weight[i][list][1] = get_se_golomb(gb);
  60                 if (pwt->luma_weight[i][list][0] != luma_def ||
  61                     pwt->luma_weight[i][list][1] != 0) {
  62                     pwt->use_weight             = 1;
  63                     pwt->luma_weight_flag[list] = 1;
  64                 }
  65             } else {
  66                 pwt->luma_weight[i][list][0] = luma_def;
  67                 pwt->luma_weight[i][list][1] = 0;
  68             }
  69
  70             if (sps->chroma_format_idc) {
  71                 chroma_weight_flag = get_bits1(gb);
  72                 if (chroma_weight_flag) {
  73                     int j;
  74                     for (j = 0; j < 2; j++) {
  75                         pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
  76                         pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
  77                         if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
  78                             pwt->chroma_weight[i][list][j][1] != 0) {
  79                             pwt->use_weight_chroma        = 1;
  80                             pwt->chroma_weight_flag[list] = 1;
  81                         }
  82                     }
  83                 } else {
  84                     int j;
  85                     for (j = 0; j < 2; j++) {
  86                         pwt->chroma_weight[i][list][j][0] = chroma_def;
  87                         pwt->chroma_weight[i][list][j][1] = 0;
  88                     }
  89                 }
  90             }
  91         }
  92         if (slice_type_nos != AV_PICTURE_TYPE_B)
  93             break;
  94     }
  95     pwt->use_weight = pwt->use_weight || pwt->use_weight_chroma;
  96     return 0;
  97 }
  98
  99 /**
 100  * Check if the top & left blocks are available if needed and
 101  * change the dc mode so it only uses the available blocks.
 102  */
 103 int ff_h264_check_intra4x4_pred_mode(int8_t *pred_mode_cache, void *logctx,
 104                                      int top_samples_available, int left_samples_available)
 105 {
 106     static const int8_t top[12] = {
 107         -1, 0, LEFT_DC_PRED, -1, -1, -1, -1, -1, 0
 108     };
 109     static const int8_t left[12] = {
 110         0, -1, TOP_DC_PRED, 0, -1, -1, -1, 0, -1, DC_128_PRED
 111     };
 112     int i;
 113
 114     if (!(top_samples_available & 0x8000)) {
 115         for (i = 0; i < 4; i++) {
 116             int status = top[pred_mode_cache[scan8[0] + i]];
 117             if (status < 0) {
 118                 av_log(logctx, AV_LOG_ERROR,
 119                        "top block unavailable for requested intra mode %d\n",
 120                        status);
 121                 return AVERROR_INVALIDDATA;
 122             } else if (status) {
 123                 pred_mode_cache[scan8[0] + i] = status;
 124             }
 125         }
 126     }
 127
 128     if ((left_samples_available & 0x8888) != 0x8888) {
 129         static const int mask[4] = { 0x8000, 0x2000, 0x80, 0x20 };
 130         for (i = 0; i < 4; i++)
 131             if (!(left_samples_available & mask[i])) {
 132                 int status = left[pred_mode_cache[scan8[0] + 8 * i]];
 133                 if (status < 0) {
 134                     av_log(logctx, AV_LOG_ERROR,
 135                            "left block unavailable for requested intra4x4 mode %d\n",
 136                            status);
 137                     return AVERROR_INVALIDDATA;
 138                 } else if (status) {
 139                     pred_mode_cache[scan8[0] + 8 * i] = status;
 140                 }
 141             }
 142     }
 143
 144     return 0;
 145 }
 146
 147 /**
 148  * Check if the top & left blocks are available if needed and
 149  * change the dc mode so it only uses the available blocks.
 150  */
 151 int ff_h264_check_intra_pred_mode(void *logctx, int top_samples_available,
 152                                   int left_samples_available,
 153                                   int mode, int is_chroma)
 154 {
 155     static const int8_t top[4]  = { LEFT_DC_PRED8x8, 1, -1, -1 };
 156     static const int8_t left[5] = { TOP_DC_PRED8x8, -1,  2, -1, DC_128_PRED8x8 };
 157
 158     if (mode > 3U) {
 159         av_log(logctx, AV_LOG_ERROR,
 160                "out of range intra chroma pred mode\n");
 161         return AVERROR_INVALIDDATA;
 162     }
 163
 164     if (!(top_samples_available & 0x8000)) {
 165         mode = top[mode];
 166         if (mode < 0) {
 167             av_log(logctx, AV_LOG_ERROR,
 168                    "top block unavailable for requested intra mode\n");
 169             return AVERROR_INVALIDDATA;
 170         }
 171     }
 172
 173     if ((left_samples_available & 0x8080) != 0x8080) {
 174         mode = left[mode];
 175         if (mode < 0) {
 176             av_log(logctx, AV_LOG_ERROR,
 177                    "left block unavailable for requested intra mode\n");
 178             return AVERROR_INVALIDDATA;
 179         }
 180         if (is_chroma && (left_samples_available & 0x8080)) {
 181             // mad cow disease mode, aka MBAFF + constrained_intra_pred
 182             mode = ALZHEIMER_DC_L0T_PRED8x8 +
 183                    (!(left_samples_available & 0x8000)) +
 184                    2 * (mode == DC_128_PRED8x8);
 185         }
 186     }
 187
 188     return mode;
 189 }
 190
 191 int ff_h264_parse_ref_count(int *plist_count, int ref_count[2],
 192                             GetBitContext *gb, const PPS *pps,
 193                             int slice_type_nos, int picture_structure, void *logctx)
 194 {
 195     int list_count;
 196     int num_ref_idx_active_override_flag;
 197
 198     // set defaults, might be overridden a few lines later
 199     ref_count[0] = pps->ref_count[0];
 200     ref_count[1] = pps->ref_count[1];
 201
 202     if (slice_type_nos != AV_PICTURE_TYPE_I) {
 203         unsigned max[2];
 204         max[0] = max[1] = picture_structure == PICT_FRAME ? 15 : 31;
 205
 206         num_ref_idx_active_override_flag = get_bits1(gb);
 207
 208         if (num_ref_idx_active_override_flag) {
 209             ref_count[0] = get_ue_golomb(gb) + 1;
 210             if (slice_type_nos == AV_PICTURE_TYPE_B) {
 211                 ref_count[1] = get_ue_golomb(gb) + 1;
 212             } else
 213                 // full range is spec-ok in this case, even for frames
 214                 ref_count[1] = 1;
 215         }
 216
 217         if (ref_count[0] - 1 > max[0] || ref_count[1] - 1 > max[1]) {
 218             av_log(logctx, AV_LOG_ERROR, "reference overflow %u > %u or %u > %u\n",
 219                    ref_count[0] - 1, max[0], ref_count[1] - 1, max[1]);
 220             ref_count[0] = ref_count[1] = 0;
 221             *plist_count = 0;
 222             goto fail;
 223         }
 224
 225         if (slice_type_nos == AV_PICTURE_TYPE_B)
 226             list_count = 2;
 227         else
 228             list_count = 1;
 229     } else {
 230         list_count   = 0;
 231         ref_count[0] = ref_count[1] = 0;
 232     }
 233
 234     *plist_count = list_count;
 235
 236     return 0;
 237 fail:
 238     *plist_count = 0;
 239     ref_count[0] = 0;
 240     ref_count[1] = 0;
 241     return AVERROR_INVALIDDATA;
 242 }
 243
 244 int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,
 245                      const SPS *sps, H264POCContext *pc,
 246                      int picture_structure, int nal_ref_idc)
 247 {
 248     const int max_frame_num = 1 << sps->log2_max_frame_num;
 249     int field_poc[2];
 250
 251     pc->frame_num_offset = pc->prev_frame_num_offset;
 252     if (pc->frame_num < pc->prev_frame_num)
 253         pc->frame_num_offset += max_frame_num;
 254
 255     if (sps->poc_type == 0) {
 256         const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
 257
 258         if (pc->poc_lsb < pc->prev_poc_lsb &&
 259             pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2)
 260             pc->poc_msb = pc->prev_poc_msb + max_poc_lsb;
 261         else if (pc->poc_lsb > pc->prev_poc_lsb &&
 262                  pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2)
 263             pc->poc_msb = pc->prev_poc_msb - max_poc_lsb;
 264         else
 265             pc->poc_msb = pc->prev_poc_msb;
 266         field_poc[0] =
 267         field_poc[1] = pc->poc_msb + pc->poc_lsb;
 268         if (picture_structure == PICT_FRAME)
 269             field_poc[1] += pc->delta_poc_bottom;
 270     } else if (sps->poc_type == 1) {
 271         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
 272         int i;
 273
 274         if (sps->poc_cycle_length != 0)
 275             abs_frame_num = pc->frame_num_offset + pc->frame_num;
 276         else
 277             abs_frame_num = 0;
 278
 279         if (nal_ref_idc == 0 && abs_frame_num > 0)
 280             abs_frame_num--;
 281
 282         expected_delta_per_poc_cycle = 0;
 283         for (i = 0; i < sps->poc_cycle_length; i++)
 284             // FIXME integrate during sps parse
 285             expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
 286
 287         if (abs_frame_num > 0) {
 288             int poc_cycle_cnt          = (abs_frame_num - 1) / sps->poc_cycle_length;
 289             int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;
 290
 291             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
 292             for (i = 0; i <= frame_num_in_poc_cycle; i++)
 293                 expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];
 294         } else
 295             expectedpoc = 0;
 296
 297         if (nal_ref_idc == 0)
 298             expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;
 299
 300         field_poc[0] = expectedpoc + pc->delta_poc[0];
 301         field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;
 302
 303         if (picture_structure == PICT_FRAME)
 304             field_poc[1] += pc->delta_poc[1];
 305     } else {
 306         int poc = 2 * (pc->frame_num_offset + pc->frame_num);
 307
 308         if (!nal_ref_idc)
 309             poc--;
 310
 311         field_poc[0] = poc;
 312         field_poc[1] = poc;
 313     }
 314
 315     if (picture_structure != PICT_BOTTOM_FIELD)
 316         pic_field_poc[0] = field_poc[0];
 317     if (picture_structure != PICT_TOP_FIELD)
 318         pic_field_poc[1] = field_poc[1];
 319     *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);
 320
 321     return 0;
 322 }
 323
 324 static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps,
 325                                int is_avc, void *logctx)
 326 {
 327     H2645Packet pkt = { 0 };
 328     int i, ret = 0;
 329
 330     ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264);
 331     if (ret < 0) {
 332         ret = 0;
 333         goto fail;
 334     }
 335
 336     for (i = 0; i < pkt.nb_nals; i++) {
 337         H2645NAL *nal = &pkt.nals[i];
 338         switch (nal->type) {
 339         case NAL_SPS:
 340             ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps, 0);
 341             if (ret < 0)
 342                 goto fail;
 343             break;
 344         case NAL_PPS:
 345             ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps,
 346                                                        nal->size_bits);
 347             if (ret < 0)
 348                 goto fail;
 349             break;
 350         default:
 351             av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n",
 352                    nal->type);
 353             break;
 354         }
 355     }
 356
 357 fail:
 358     ff_h2645_packet_uninit(&pkt);
 359     return ret;
 360 }
 361
 362 /* There are (invalid) samples in the wild with mp4-style extradata, where the
 363  * parameter sets are stored unescaped (i.e. as RBSP).
 364  * This function catches the parameter set decoding failure and tries again
 365  * after escaping it */
 366 static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps,
 367                                    int err_recognition, void *logctx)
 368 {
 369     int ret;
 370
 371     ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx);
 372     if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) {
 373         GetByteContext gbc;
 374         PutByteContext pbc;
 375         uint8_t *escaped_buf;
 376         int escaped_buf_size;
 377
 378         av_log(logctx, AV_LOG_WARNING,
 379                "SPS decoding failure, trying again after escaping the NAL\n");
 380
 381         if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3)
 382             return AVERROR(ERANGE);
 383         escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE;
 384         escaped_buf = av_mallocz(escaped_buf_size);
 385         if (!escaped_buf)
 386             return AVERROR(ENOMEM);
 387
 388         bytestream2_init(&gbc, buf, buf_size);
 389         bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size);
 390
 391         while (bytestream2_get_bytes_left(&gbc)) {
 392             if (bytestream2_get_bytes_left(&gbc) >= 3 &&
 393                 bytestream2_peek_be24(&gbc) <= 3) {
 394                 bytestream2_put_be24(&pbc, 3);
 395                 bytestream2_skip(&gbc, 2);
 396             } else
 397                 bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
 398         }
 399
 400         escaped_buf_size = bytestream2_tell_p(&pbc);
 401         AV_WB16(escaped_buf, escaped_buf_size - 2);
 402
 403         ret = decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx);
 404         av_freep(&escaped_buf);
 405         if (ret < 0)
 406             return ret;
 407     }
 408
 409     return 0;
 410 }
 411
 412 int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
 413                              int *is_avc, int *nal_length_size,
 414                              int err_recognition, void *logctx)
 415 {
 416     int ret;
 417
 418     if (!data || size <= 0)
 419         return -1;
 420
 421     if (data[0] == 1) {
 422         int i, cnt, nalsize;
 423         const uint8_t *p = data;
 424
 425         *is_avc = 1;
 426
 427         if (size < 7) {
 428             av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size);
 429             return AVERROR_INVALIDDATA;
 430         }
 431
 432         // Decode sps from avcC
 433         cnt = *(p + 5) & 0x1f; // Number of sps
 434         p  += 6;
 435         for (i = 0; i < cnt; i++) {
 436             nalsize = AV_RB16(p) + 2;
 437             if (nalsize > size - (p - data))
 438                 return AVERROR_INVALIDDATA;
 439             ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
 440             if (ret < 0) {
 441                 av_log(logctx, AV_LOG_ERROR,
 442                        "Decoding sps %d from avcC failed\n", i);
 443                 return ret;
 444             }
 445             p += nalsize;
 446         }
 447         // Decode pps from avcC
 448         cnt = *(p++); // Number of pps
 449         for (i = 0; i < cnt; i++) {
 450             nalsize = AV_RB16(p) + 2;
 451             if (nalsize > size - (p - data))
 452                 return AVERROR_INVALIDDATA;
 453             ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
 454             if (ret < 0) {
 455                 av_log(logctx, AV_LOG_ERROR,
 456                        "Decoding pps %d from avcC failed\n", i);
 457                 return ret;
 458             }
 459             p += nalsize;
 460         }
 461         // Store right nal length size that will be used to parse all other nals
 462         *nal_length_size = (data[4] & 0x03) + 1;
 463     } else {
 464         *is_avc = 0;
 465         ret = decode_extradata_ps(data, size, ps, 0, logctx);
 466         if (ret < 0)
 467             return ret;
 468     }
 469     return size;
 470 }
 471
 472 /**
 473  * Compute profile from profile_idc and constraint_set?_flags.
 474  *
 475  * @param sps SPS
 476  *
 477  * @return profile as defined by FF_PROFILE_H264_*
 478  */
 479 int ff_h264_get_profile(const SPS *sps)
 480 {
 481     int profile = sps->profile_idc;
 482
 483     switch (sps->profile_idc) {
 484     case FF_PROFILE_H264_BASELINE:
 485         // constraint_set1_flag set to 1
 486         profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0;
 487         break;
 488     case FF_PROFILE_H264_HIGH_10:
 489     case FF_PROFILE_H264_HIGH_422:
 490     case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
 491         // constraint_set3_flag set to 1
 492         profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0;
 493         break;
 494     }
 495
 496     return profile;
 497 }