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