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

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