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 "h264dec.h"
  24 #include "h264_parse.h"
  25 #include "h264_ps.h"
  26
  27 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
  28                               const int *ref_count, int slice_type_nos,
  29                               H264PredWeightTable *pwt)
  30 {
  31     int list, i, j;
  32     int luma_def, chroma_def;
  33
  34     pwt->use_weight             = 0;
  35     pwt->use_weight_chroma      = 0;
  36     pwt->luma_log2_weight_denom = get_ue_golomb(gb);
  37     if (sps->chroma_format_idc)
  38         pwt->chroma_log2_weight_denom = get_ue_golomb(gb);
  39     luma_def   = 1 << pwt->luma_log2_weight_denom;
  40     chroma_def = 1 << pwt->chroma_log2_weight_denom;
  41
  42     for (list = 0; list < 2; list++) {
  43         pwt->luma_weight_flag[list]   = 0;
  44         pwt->chroma_weight_flag[list] = 0;
  45         for (i = 0; i < ref_count[list]; i++) {
  46             int luma_weight_flag, chroma_weight_flag;
  47
  48             luma_weight_flag = get_bits1(gb);
  49             if (luma_weight_flag) {
  50                 pwt->luma_weight[i][list][0] = get_se_golomb(gb);
  51                 pwt->luma_weight[i][list][1] = get_se_golomb(gb);
  52                 if (pwt->luma_weight[i][list][0] != luma_def ||
  53                     pwt->luma_weight[i][list][1] != 0) {
  54                     pwt->use_weight             = 1;
  55                     pwt->luma_weight_flag[list] = 1;
  56                 }
  57             } else {
  58                 pwt->luma_weight[i][list][0] = luma_def;
  59                 pwt->luma_weight[i][list][1] = 0;
  60             }
  61
  62             if (sps->chroma_format_idc) {
  63                 chroma_weight_flag = get_bits1(gb);
  64                 if (chroma_weight_flag) {
  65                     int j;
  66                     for (j = 0; j < 2; j++) {
  67                         pwt->chroma_weight[i][list][j][0] = get_se_golomb(gb);
  68                         pwt->chroma_weight[i][list][j][1] = get_se_golomb(gb);
  69                         if (pwt->chroma_weight[i][list][j][0] != chroma_def ||
  70                             pwt->chroma_weight[i][list][j][1] != 0) {
  71                             pwt->use_weight_chroma        = 1;
  72                             pwt->chroma_weight_flag[list] = 1;
  73                         }
  74                     }
  75                 } else {
  76                     int j;
  77                     for (j = 0; j < 2; j++) {
  78                         pwt->chroma_weight[i][list][j][0] = chroma_def;
  79                         pwt->chroma_weight[i][list][j][1] = 0;
  80                     }
  81                 }
  82             }
  83
  84             // for MBAFF
  85             pwt->luma_weight[16 + 2 * i][list][0] = pwt->luma_weight[16 + 2 * i + 1][list][0] = pwt->luma_weight[i][list][0];
  86             pwt->luma_weight[16 + 2 * i][list][1] = pwt->luma_weight[16 + 2 * i + 1][list][1] = pwt->luma_weight[i][list][1];
  87             for (j = 0; j < 2; j++) {
  88                 pwt->chroma_weight[16 + 2 * i][list][j][0] = pwt->chroma_weight[16 + 2 * i + 1][list][j][0] = pwt->chroma_weight[i][list][j][0];
  89                 pwt->chroma_weight[16 + 2 * i][list][j][1] = pwt->chroma_weight[16 + 2 * i + 1][list][j][1] = pwt->chroma_weight[i][list][j][1];
  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 intra4x4 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 (is_chroma && (left_samples_available & 0x8080)) {
 176             // mad cow disease mode, aka MBAFF + constrained_intra_pred
 177             mode = ALZHEIMER_DC_L0T_PRED8x8 +
 178                    (!(left_samples_available & 0x8000)) +
 179                    2 * (mode == DC_128_PRED8x8);
 180         }
 181         if (mode < 0) {
 182             av_log(logctx, AV_LOG_ERROR,
 183                    "left block unavailable for requested intra mode\n");
 184             return AVERROR_INVALIDDATA;
 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)
 194 {
 195     int list_count;
 196     int num_ref_idx_active_override_flag, max_refs;
 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         num_ref_idx_active_override_flag = get_bits1(gb);
 204
 205         if (num_ref_idx_active_override_flag) {
 206             ref_count[0] = get_ue_golomb(gb) + 1;
 207             if (ref_count[0] < 1)
 208                 goto fail;
 209             if (slice_type_nos == AV_PICTURE_TYPE_B) {
 210                 ref_count[1] = get_ue_golomb(gb) + 1;
 211                 if (ref_count[1] < 1)
 212                     goto fail;
 213             }
 214         }
 215
 216         if (slice_type_nos == AV_PICTURE_TYPE_B)
 217             list_count = 2;
 218         else
 219             list_count = 1;
 220     } else {
 221         list_count   = 0;
 222         ref_count[0] = ref_count[1] = 0;
 223     }
 224
 225     max_refs = picture_structure == PICT_FRAME ? 16 : 32;
 226
 227     if (ref_count[0] > max_refs || ref_count[1] > max_refs)
 228         goto fail;
 229
 230     *plist_count = list_count;
 231
 232     return 0;
 233 fail:
 234     *plist_count = 0;
 235     ref_count[0] = 0;
 236     ref_count[1] = 0;
 237     return AVERROR_INVALIDDATA;
 238 }
 239
 240 int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc,
 241                      const SPS *sps, H264POCContext *pc,
 242                      int picture_structure, int nal_ref_idc)
 243 {
 244     const int max_frame_num = 1 << sps->log2_max_frame_num;
 245     int field_poc[2];
 246
 247     pc->frame_num_offset = pc->prev_frame_num_offset;
 248     if (pc->frame_num < pc->prev_frame_num)
 249         pc->frame_num_offset += max_frame_num;
 250
 251     if (sps->poc_type == 0) {
 252         const int max_poc_lsb = 1 << sps->log2_max_poc_lsb;
 253
 254         if (pc->poc_lsb < pc->prev_poc_lsb &&
 255             pc->prev_poc_lsb - pc->poc_lsb >= max_poc_lsb / 2)
 256             pc->poc_msb = pc->prev_poc_msb + max_poc_lsb;
 257         else if (pc->poc_lsb > pc->prev_poc_lsb &&
 258                  pc->prev_poc_lsb - pc->poc_lsb < -max_poc_lsb / 2)
 259             pc->poc_msb = pc->prev_poc_msb - max_poc_lsb;
 260         else
 261             pc->poc_msb = pc->prev_poc_msb;
 262         field_poc[0] =
 263         field_poc[1] = pc->poc_msb + pc->poc_lsb;
 264         if (picture_structure == PICT_FRAME)
 265             field_poc[1] += pc->delta_poc_bottom;
 266     } else if (sps->poc_type == 1) {
 267         int abs_frame_num, expected_delta_per_poc_cycle, expectedpoc;
 268         int i;
 269
 270         if (sps->poc_cycle_length != 0)
 271             abs_frame_num = pc->frame_num_offset + pc->frame_num;
 272         else
 273             abs_frame_num = 0;
 274
 275         if (nal_ref_idc == 0 && abs_frame_num > 0)
 276             abs_frame_num--;
 277
 278         expected_delta_per_poc_cycle = 0;
 279         for (i = 0; i < sps->poc_cycle_length; i++)
 280             // FIXME integrate during sps parse
 281             expected_delta_per_poc_cycle += sps->offset_for_ref_frame[i];
 282
 283         if (abs_frame_num > 0) {
 284             int poc_cycle_cnt          = (abs_frame_num - 1) / sps->poc_cycle_length;
 285             int frame_num_in_poc_cycle = (abs_frame_num - 1) % sps->poc_cycle_length;
 286
 287             expectedpoc = poc_cycle_cnt * expected_delta_per_poc_cycle;
 288             for (i = 0; i <= frame_num_in_poc_cycle; i++)
 289                 expectedpoc = expectedpoc + sps->offset_for_ref_frame[i];
 290         } else
 291             expectedpoc = 0;
 292
 293         if (nal_ref_idc == 0)
 294             expectedpoc = expectedpoc + sps->offset_for_non_ref_pic;
 295
 296         field_poc[0] = expectedpoc + pc->delta_poc[0];
 297         field_poc[1] = field_poc[0] + sps->offset_for_top_to_bottom_field;
 298
 299         if (picture_structure == PICT_FRAME)
 300             field_poc[1] += pc->delta_poc[1];
 301     } else {
 302         int poc = 2 * (pc->frame_num_offset + pc->frame_num);
 303
 304         if (!nal_ref_idc)
 305             poc--;
 306
 307         field_poc[0] = poc;
 308         field_poc[1] = poc;
 309     }
 310
 311     if (picture_structure != PICT_BOTTOM_FIELD)
 312         pic_field_poc[0] = field_poc[0];
 313     if (picture_structure != PICT_TOP_FIELD)
 314         pic_field_poc[1] = field_poc[1];
 315     *pic_poc = FFMIN(pic_field_poc[0], pic_field_poc[1]);
 316
 317     return 0;
 318 }
 319
 320 static int decode_extradata_ps(const uint8_t *data, int size, H264ParamSets *ps,
 321                                int is_avc, void *logctx)
 322 {
 323     H2645Packet pkt = { 0 };
 324     int i, ret = 0;
 325
 326     ret = ff_h2645_packet_split(&pkt, data, size, logctx, is_avc, 2, AV_CODEC_ID_H264);
 327     if (ret < 0)
 328         goto fail;
 329
 330     for (i = 0; i < pkt.nb_nals; i++) {
 331         H2645NAL *nal = &pkt.nals[i];
 332         switch (nal->type) {
 333         case H264_NAL_SPS:
 334             ret = ff_h264_decode_seq_parameter_set(&nal->gb, logctx, ps);
 335             if (ret < 0)
 336                 goto fail;
 337             break;
 338         case H264_NAL_PPS:
 339             ret = ff_h264_decode_picture_parameter_set(&nal->gb, logctx, ps,
 340                                                        nal->size_bits);
 341             if (ret < 0)
 342                 goto fail;
 343             break;
 344         default:
 345             av_log(logctx, AV_LOG_VERBOSE, "Ignoring NAL type %d in extradata\n",
 346                    nal->type);
 347             break;
 348         }
 349     }
 350
 351 fail:
 352     ff_h2645_packet_uninit(&pkt);
 353     return ret;
 354 }
 355
 356 /* There are (invalid) samples in the wild with mp4-style extradata, where the
 357  * parameter sets are stored unescaped (i.e. as RBSP).
 358  * This function catches the parameter set decoding failure and tries again
 359  * after escaping it */
 360 static int decode_extradata_ps_mp4(const uint8_t *buf, int buf_size, H264ParamSets *ps,
 361                                    int err_recognition, void *logctx)
 362 {
 363     int ret;
 364
 365     ret = decode_extradata_ps(buf, buf_size, ps, 1, logctx);
 366     if (ret < 0 && !(err_recognition & AV_EF_EXPLODE)) {
 367         GetByteContext gbc;
 368         PutByteContext pbc;
 369         uint8_t *escaped_buf;
 370         int escaped_buf_size;
 371
 372         av_log(logctx, AV_LOG_WARNING,
 373                "SPS decoding failure, trying again after escaping the NAL\n");
 374
 375         if (buf_size / 2 >= (INT16_MAX - AV_INPUT_BUFFER_PADDING_SIZE) / 3)
 376             return AVERROR(ERANGE);
 377         escaped_buf_size = buf_size * 3 / 2 + AV_INPUT_BUFFER_PADDING_SIZE;
 378         escaped_buf = av_mallocz(escaped_buf_size);
 379         if (!escaped_buf)
 380             return AVERROR(ENOMEM);
 381
 382         bytestream2_init(&gbc, buf, buf_size);
 383         bytestream2_init_writer(&pbc, escaped_buf, escaped_buf_size);
 384
 385         while (bytestream2_get_bytes_left(&gbc)) {
 386             if (bytestream2_get_bytes_left(&gbc) >= 3 &&
 387                 bytestream2_peek_be24(&gbc) <= 3) {
 388                 bytestream2_put_be24(&pbc, 3);
 389                 bytestream2_skip(&gbc, 2);
 390             } else
 391                 bytestream2_put_byte(&pbc, bytestream2_get_byte(&gbc));
 392         }
 393
 394         escaped_buf_size = bytestream2_tell_p(&pbc);
 395         AV_WB16(escaped_buf, escaped_buf_size - 2);
 396
 397         ret = decode_extradata_ps(escaped_buf, escaped_buf_size, ps, 1, logctx);
 398         av_freep(&escaped_buf);
 399         if (ret < 0)
 400             return ret;
 401     }
 402
 403     return 0;
 404 }
 405
 406 int ff_h264_decode_extradata(const uint8_t *data, int size, H264ParamSets *ps,
 407                              int *is_avc, int *nal_length_size,
 408                              int err_recognition, void *logctx)
 409 {
 410     int ret;
 411
 412     if (data[0] == 1) {
 413         int i, cnt, nalsize;
 414         const uint8_t *p = data;
 415
 416         *is_avc = 1;
 417
 418         if (size < 7) {
 419             av_log(logctx, AV_LOG_ERROR, "avcC %d too short\n", size);
 420             return AVERROR_INVALIDDATA;
 421         }
 422
 423         // Decode sps from avcC
 424         cnt = *(p + 5) & 0x1f; // Number of sps
 425         p  += 6;
 426         for (i = 0; i < cnt; i++) {
 427             nalsize = AV_RB16(p) + 2;
 428             if (p - data + nalsize > size)
 429                 return AVERROR_INVALIDDATA;
 430             ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
 431             if (ret < 0) {
 432                 av_log(logctx, AV_LOG_ERROR,
 433                        "Decoding sps %d from avcC failed\n", i);
 434                 return ret;
 435             }
 436             p += nalsize;
 437         }
 438         // Decode pps from avcC
 439         cnt = *(p++); // Number of pps
 440         for (i = 0; i < cnt; i++) {
 441             nalsize = AV_RB16(p) + 2;
 442             if (p - data + nalsize > size)
 443                 return AVERROR_INVALIDDATA;
 444             ret = decode_extradata_ps_mp4(p, nalsize, ps, err_recognition, logctx);
 445             if (ret < 0) {
 446                 av_log(logctx, AV_LOG_ERROR,
 447                        "Decoding pps %d from avcC failed\n", i);
 448                 return ret;
 449             }
 450             p += nalsize;
 451         }
 452         // Store right nal length size that will be used to parse all other nals
 453         *nal_length_size = (data[4] & 0x03) + 1;
 454     } else {
 455         *is_avc = 0;
 456         ret = decode_extradata_ps(data, size, ps, 0, logctx);
 457         if (ret < 0)
 458             return ret;
 459     }
 460     return 0;
 461 }
 462
 463 /**
 464  * Compute profile from profile_idc and constraint_set?_flags.
 465  *
 466  * @param sps SPS
 467  *
 468  * @return profile as defined by FF_PROFILE_H264_*
 469  */
 470 int ff_h264_get_profile(const SPS *sps)
 471 {
 472     int profile = sps->profile_idc;
 473
 474     switch (sps->profile_idc) {
 475     case FF_PROFILE_H264_BASELINE:
 476         // constraint_set1_flag set to 1
 477         profile |= (sps->constraint_set_flags & 1 << 1) ? FF_PROFILE_H264_CONSTRAINED : 0;
 478         break;
 479     case FF_PROFILE_H264_HIGH_10:
 480     case FF_PROFILE_H264_HIGH_422:
 481     case FF_PROFILE_H264_HIGH_444_PREDICTIVE:
 482         // constraint_set3_flag set to 1
 483         profile |= (sps->constraint_set_flags & 1 << 3) ? FF_PROFILE_H264_INTRA : 0;
 484         break;
 485     }
 486
 487     return profile;
 488 }