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

   1 /*
   2  * AVC helper functions for muxers
   3  * Copyright (c) 2006 Baptiste Coudurier <baptiste.coudurier@smartjog.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/intreadwrite.h"
  23 #include "libavcodec/h264.h"
  24 #include "libavcodec/get_bits.h"
  25 #include "avformat.h"
  26 #include "avio.h"
  27 #include "avc.h"
  28
  29 static const uint8_t *ff_avc_find_startcode_internal(const uint8_t *p, const uint8_t *end)
  30 {
  31     const uint8_t *a = p + 4 - ((intptr_t)p & 3);
  32
  33     for (end -= 3; p < a && p < end; p++) {
  34         if (p[0] == 0 && p[1] == 0 && p[2] == 1)
  35             return p;
  36     }
  37
  38     for (end -= 3; p < end; p += 4) {
  39         uint32_t x = *(const uint32_t*)p;
  40 //      if ((x - 0x01000100) & (~x) & 0x80008000) // little endian
  41 //      if ((x - 0x00010001) & (~x) & 0x00800080) // big endian
  42         if ((x - 0x01010101) & (~x) & 0x80808080) { // generic
  43             if (p[1] == 0) {
  44                 if (p[0] == 0 && p[2] == 1)
  45                     return p;
  46                 if (p[2] == 0 && p[3] == 1)
  47                     return p+1;
  48             }
  49             if (p[3] == 0) {
  50                 if (p[2] == 0 && p[4] == 1)
  51                     return p+2;
  52                 if (p[4] == 0 && p[5] == 1)
  53                     return p+3;
  54             }
  55         }
  56     }
  57
  58     for (end += 3; p < end; p++) {
  59         if (p[0] == 0 && p[1] == 0 && p[2] == 1)
  60             return p;
  61     }
  62
  63     return end + 3;
  64 }
  65
  66 const uint8_t *ff_avc_find_startcode(const uint8_t *p, const uint8_t *end){
  67     const uint8_t *out= ff_avc_find_startcode_internal(p, end);
  68     if(p<out && out<end && !out[-1]) out--;
  69     return out;
  70 }
  71
  72 int ff_avc_parse_nal_units(AVIOContext *pb, const uint8_t *buf_in, int size)
  73 {
  74     const uint8_t *p = buf_in;
  75     const uint8_t *end = p + size;
  76     const uint8_t *nal_start, *nal_end;
  77
  78     size = 0;
  79     nal_start = ff_avc_find_startcode(p, end);
  80     for (;;) {
  81         while (nal_start < end && !*(nal_start++));
  82         if (nal_start == end)
  83             break;
  84
  85         nal_end = ff_avc_find_startcode(nal_start, end);
  86         avio_wb32(pb, nal_end - nal_start);
  87         avio_write(pb, nal_start, nal_end - nal_start);
  88         size += 4 + nal_end - nal_start;
  89         nal_start = nal_end;
  90     }
  91     return size;
  92 }
  93
  94 int ff_avc_parse_nal_units_buf(const uint8_t *buf_in, uint8_t **buf, int *size)
  95 {
  96     AVIOContext *pb;
  97     int ret = avio_open_dyn_buf(&pb);
  98     if(ret < 0)
  99         return ret;
 100
 101     ff_avc_parse_nal_units(pb, buf_in, *size);
 102
 103     av_freep(buf);
 104     *size = avio_close_dyn_buf(pb, buf);
 105     return 0;
 106 }
 107
 108 int ff_isom_write_avcc(AVIOContext *pb, const uint8_t *data, int len)
 109 {
 110     AVIOContext *sps_pb = NULL, *pps_pb = NULL;
 111     uint8_t *buf = NULL, *end, *start = NULL;
 112     uint8_t *sps = NULL, *pps = NULL;
 113     uint32_t sps_size = 0, pps_size = 0;
 114     int ret, nb_sps = 0, nb_pps = 0;
 115
 116     if (len <= 6)
 117         return AVERROR_INVALIDDATA;
 118
 119     /* check for H.264 start code */
 120     if (AV_RB32(data) != 0x00000001 &&
 121         AV_RB24(data) != 0x000001) {
 122         avio_write(pb, data, len);
 123         return 0;
 124     }
 125
 126     ret = ff_avc_parse_nal_units_buf(data, &buf, &len);
 127     if (ret < 0)
 128         return ret;
 129     start = buf;
 130     end = buf + len;
 131
 132     ret = avio_open_dyn_buf(&sps_pb);
 133     if (ret < 0)
 134         goto fail;
 135     ret = avio_open_dyn_buf(&pps_pb);
 136     if (ret < 0)
 137         goto fail;
 138
 139     /* look for sps and pps */
 140     while (end - buf > 4) {
 141         uint32_t size;
 142         uint8_t nal_type;
 143         size = FFMIN(AV_RB32(buf), end - buf - 4);
 144         buf += 4;
 145         nal_type = buf[0] & 0x1f;
 146
 147         if (nal_type == 7) { /* SPS */
 148             nb_sps++;
 149             if (size > UINT16_MAX || nb_sps >= H264_MAX_SPS_COUNT) {
 150                 ret = AVERROR_INVALIDDATA;
 151                 goto fail;
 152             }
 153             avio_wb16(sps_pb, size);
 154             avio_write(sps_pb, buf, size);
 155         } else if (nal_type == 8) { /* PPS */
 156             nb_pps++;
 157             if (size > UINT16_MAX || nb_pps >= H264_MAX_PPS_COUNT) {
 158                 ret = AVERROR_INVALIDDATA;
 159                 goto fail;
 160             }
 161             avio_wb16(pps_pb, size);
 162             avio_write(pps_pb, buf, size);
 163         }
 164
 165         buf += size;
 166     }
 167     sps_size = avio_close_dyn_buf(sps_pb, &sps);
 168     pps_size = avio_close_dyn_buf(pps_pb, &pps);
 169
 170     if (sps_size < 6 || !pps_size) {
 171         ret = AVERROR_INVALIDDATA;
 172         goto fail;
 173     }
 174
 175     avio_w8(pb, 1); /* version */
 176     avio_w8(pb, sps[3]); /* profile */
 177     avio_w8(pb, sps[4]); /* profile compat */
 178     avio_w8(pb, sps[5]); /* level */
 179     avio_w8(pb, 0xff); /* 6 bits reserved (111111) + 2 bits nal size length - 1 (11) */
 180     avio_w8(pb, 0xe0 | nb_sps); /* 3 bits reserved (111) + 5 bits number of sps */
 181
 182     avio_write(pb, sps, sps_size);
 183     avio_w8(pb, nb_pps); /* number of pps */
 184     avio_write(pb, pps, pps_size);
 185
 186 fail:
 187     if (!sps)
 188         avio_close_dyn_buf(sps_pb, &sps);
 189     if (!pps)
 190         avio_close_dyn_buf(pps_pb, &pps);
 191     av_free(sps);
 192     av_free(pps);
 193     av_free(start);
 194
 195     return ret;
 196 }
 197
 198 int ff_avc_write_annexb_extradata(const uint8_t *in, uint8_t **buf, int *size)
 199 {
 200     uint16_t sps_size, pps_size;
 201     uint8_t *out;
 202     int out_size;
 203
 204     *buf = NULL;
 205     if (*size >= 4 && (AV_RB32(in) == 0x00000001 || AV_RB24(in) == 0x000001))
 206         return 0;
 207     if (*size < 11 || in[0] != 1)
 208         return AVERROR_INVALIDDATA;
 209
 210     sps_size = AV_RB16(&in[6]);
 211     if (11 + sps_size > *size)
 212         return AVERROR_INVALIDDATA;
 213     pps_size = AV_RB16(&in[9 + sps_size]);
 214     if (11 + sps_size + pps_size > *size)
 215         return AVERROR_INVALIDDATA;
 216     out_size = 8 + sps_size + pps_size;
 217     out = av_mallocz(out_size + AV_INPUT_BUFFER_PADDING_SIZE);
 218     if (!out)
 219         return AVERROR(ENOMEM);
 220     AV_WB32(&out[0], 0x00000001);
 221     memcpy(out + 4, &in[8], sps_size);
 222     AV_WB32(&out[4 + sps_size], 0x00000001);
 223     memcpy(out + 8 + sps_size, &in[11 + sps_size], pps_size);
 224     *buf = out;
 225     *size = out_size;
 226     return 0;
 227 }
 228
 229 const uint8_t *ff_avc_mp4_find_startcode(const uint8_t *start,
 230                                          const uint8_t *end,
 231                                          int nal_length_size)
 232 {
 233     unsigned int res = 0;
 234
 235     if (end - start < nal_length_size)
 236         return NULL;
 237     while (nal_length_size--)
 238         res = (res << 8) | *start++;
 239
 240     if (res > end - start)
 241         return NULL;
 242
 243     return start + res;
 244 }
 245
 246 uint8_t *ff_nal_unit_extract_rbsp(const uint8_t *src, uint32_t src_len,
 247                                   uint32_t *dst_len, int header_len)
 248 {
 249     uint8_t *dst;
 250     uint32_t i, len;
 251
 252     dst = av_malloc(src_len + AV_INPUT_BUFFER_PADDING_SIZE);
 253     if (!dst)
 254         return NULL;
 255
 256     /* NAL unit header */
 257     i = len = 0;
 258     while (i < header_len && i < src_len)
 259         dst[len++] = src[i++];
 260
 261     while (i + 2 < src_len)
 262         if (!src[i] && !src[i + 1] && src[i + 2] == 3) {
 263             dst[len++] = src[i++];
 264             dst[len++] = src[i++];
 265             i++; // remove emulation_prevention_three_byte
 266         } else
 267             dst[len++] = src[i++];
 268
 269     while (i < src_len)
 270         dst[len++] = src[i++];
 271
 272     memset(dst + len, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 273
 274     *dst_len = len;
 275     return dst;
 276 }
 277
 278 static const AVRational avc_sample_aspect_ratio[17] = {
 279     {   0,  1 },
 280     {   1,  1 },
 281     {  12, 11 },
 282     {  10, 11 },
 283     {  16, 11 },
 284     {  40, 33 },
 285     {  24, 11 },
 286     {  20, 11 },
 287     {  32, 11 },
 288     {  80, 33 },
 289     {  18, 11 },
 290     {  15, 11 },
 291     {  64, 33 },
 292     { 160, 99 },
 293     {   4,  3 },
 294     {   3,  2 },
 295     {   2,  1 },
 296 };
 297
 298 static inline int get_ue_golomb(GetBitContext *gb) {
 299     int i;
 300     for (i = 0; i < 32 && !get_bits1(gb); i++)
 301         ;
 302     return get_bitsz(gb, i) + (1 << i) - 1;
 303 }
 304
 305 static inline int get_se_golomb(GetBitContext *gb) {
 306     int v = get_ue_golomb(gb) + 1;
 307     int sign = -(v & 1);
 308     return ((v >> 1) ^ sign) - sign;
 309 }
 310
 311 H264SequenceParameterSet *ff_avc_decode_sps(const uint8_t *buf, int buf_size)
 312 {
 313     int i, j, ret, rbsp_size, aspect_ratio_idc, pic_order_cnt_type;
 314     int num_ref_frames_in_pic_order_cnt_cycle;
 315     int delta_scale, lastScale = 8, nextScale = 8;
 316     int sizeOfScalingList;
 317     H264SequenceParameterSet *sps = NULL;
 318     GetBitContext gb;
 319     uint8_t *rbsp_buf;
 320
 321     rbsp_buf = ff_nal_unit_extract_rbsp(buf, buf_size, &rbsp_size, 0);
 322     if (!rbsp_buf)
 323         return NULL;
 324
 325     ret = init_get_bits8(&gb, rbsp_buf, rbsp_size);
 326     if (ret < 0)
 327         goto end;
 328
 329     sps = av_mallocz(sizeof(*sps));
 330     if (!sps)
 331         goto end;
 332
 333     sps->profile_idc = get_bits(&gb, 8);
 334     sps->constraint_set_flags |= get_bits1(&gb) << 0; // constraint_set0_flag
 335     sps->constraint_set_flags |= get_bits1(&gb) << 1; // constraint_set1_flag
 336     sps->constraint_set_flags |= get_bits1(&gb) << 2; // constraint_set2_flag
 337     sps->constraint_set_flags |= get_bits1(&gb) << 3; // constraint_set3_flag
 338     sps->constraint_set_flags |= get_bits1(&gb) << 4; // constraint_set4_flag
 339     sps->constraint_set_flags |= get_bits1(&gb) << 5; // constraint_set5_flag
 340     skip_bits(&gb, 2); // reserved_zero_2bits
 341     sps->level_idc = get_bits(&gb, 8);
 342     sps->id = get_ue_golomb(&gb);
 343
 344     if (sps->profile_idc == 100 || sps->profile_idc == 110 ||
 345         sps->profile_idc == 122 || sps->profile_idc == 244 || sps->profile_idc ==  44 ||
 346         sps->profile_idc ==  83 || sps->profile_idc ==  86 || sps->profile_idc == 118 ||
 347         sps->profile_idc == 128 || sps->profile_idc == 138 || sps->profile_idc == 139 ||
 348         sps->profile_idc == 134) {
 349         sps->chroma_format_idc = get_ue_golomb(&gb); // chroma_format_idc
 350         if (sps->chroma_format_idc == 3) {
 351             skip_bits1(&gb); // separate_colour_plane_flag
 352         }
 353         sps->bit_depth_luma = get_ue_golomb(&gb) + 8;
 354         get_ue_golomb(&gb); // bit_depth_chroma_minus8
 355         skip_bits1(&gb); // qpprime_y_zero_transform_bypass_flag
 356         if (get_bits1(&gb)) { // seq_scaling_matrix_present_flag
 357             for (i = 0; i < ((sps->chroma_format_idc != 3) ? 8 : 12); i++) {
 358                 if (!get_bits1(&gb)) // seq_scaling_list_present_flag
 359                     continue;
 360                 lastScale = 8;
 361                 nextScale = 8;
 362                 sizeOfScalingList = i < 6 ? 16 : 64;
 363                 for (j = 0; j < sizeOfScalingList; j++) {
 364                     if (nextScale != 0) {
 365                         delta_scale = get_se_golomb(&gb);
 366                         nextScale = (lastScale + delta_scale) & 0xff;
 367                     }
 368                     lastScale = nextScale == 0 ? lastScale : nextScale;
 369                 }
 370             }
 371         }
 372     } else {
 373         sps->chroma_format_idc = 1;
 374         sps->bit_depth_luma = 8;
 375     }
 376
 377     get_ue_golomb(&gb); // log2_max_frame_num_minus4
 378     pic_order_cnt_type = get_ue_golomb(&gb);
 379
 380     if (pic_order_cnt_type == 0) {
 381         get_ue_golomb(&gb); // log2_max_pic_order_cnt_lsb_minus4
 382     } else if (pic_order_cnt_type == 1) {
 383         skip_bits1(&gb);    // delta_pic_order_always_zero
 384         get_se_golomb(&gb); // offset_for_non_ref_pic
 385         get_se_golomb(&gb); // offset_for_top_to_bottom_field
 386         num_ref_frames_in_pic_order_cnt_cycle = get_ue_golomb(&gb);
 387         for (i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++)
 388             get_se_golomb(&gb); // offset_for_ref_frame
 389     }
 390
 391     get_ue_golomb(&gb); // max_num_ref_frames
 392     skip_bits1(&gb); // gaps_in_frame_num_value_allowed_flag
 393     get_ue_golomb(&gb); // pic_width_in_mbs_minus1
 394     get_ue_golomb(&gb); // pic_height_in_map_units_minus1
 395
 396     sps->frame_mbs_only_flag = get_bits1(&gb);
 397     if (!sps->frame_mbs_only_flag)
 398         skip_bits1(&gb); // mb_adaptive_frame_field_flag
 399
 400     skip_bits1(&gb); // direct_8x8_inference_flag
 401
 402     if (get_bits1(&gb)) { // frame_cropping_flag
 403         get_ue_golomb(&gb); // frame_crop_left_offset
 404         get_ue_golomb(&gb); // frame_crop_right_offset
 405         get_ue_golomb(&gb); // frame_crop_top_offset
 406         get_ue_golomb(&gb); // frame_crop_bottom_offset
 407     }
 408
 409     if (get_bits1(&gb)) { // vui_parameters_present_flag
 410         if (get_bits1(&gb)) { // aspect_ratio_info_present_flag
 411             aspect_ratio_idc = get_bits(&gb, 8);
 412             if (aspect_ratio_idc == 0xff) {
 413                 sps->sar.num = get_bits(&gb, 16);
 414                 sps->sar.den = get_bits(&gb, 16);
 415             } else if (aspect_ratio_idc < FF_ARRAY_ELEMS(avc_sample_aspect_ratio)) {
 416                 sps->sar = avc_sample_aspect_ratio[aspect_ratio_idc];
 417             }
 418         }
 419     }
 420
 421     if (!sps->sar.den) {
 422         sps->sar.num = 1;
 423         sps->sar.den = 1;
 424     }
 425
 426  end:
 427     av_free(rbsp_buf);
 428     return sps;
 429 }