Merge commit '7157d959264f3729da463725c6faa580d9394d19'
authorMark Thompson <sw@jkqxz.net>
Wed, 21 Feb 2018 22:41:00 +0000 (22:41 +0000)
committerMark Thompson <sw@jkqxz.net>
Wed, 21 Feb 2018 22:41:00 +0000 (22:41 +0000)
* commit '7157d959264f3729da463725c6faa580d9394d19':
  cbs_h264: Move slice_group_id array out of PPS structure

Merged-by: Mark Thompson <sw@jkqxz.net>
1  2 
libavcodec/cbs_h264.h
libavcodec/cbs_h2645.c
libavcodec/cbs_h264_syntax_template.c

diff --combined libavcodec/cbs_h264.h
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -195,7 -195,9 +195,9 @@@ typedef struct H264RawPPS 
      uint8_t slice_group_change_direction_flag;
      uint16_t slice_group_change_rate_minus1;
      uint16_t pic_size_in_map_units_minus1;
-     uint8_t slice_group_id[H264_MAX_MB_PIC_SIZE];
+     uint8_t *slice_group_id;
+     AVBufferRef *slice_group_id_ref;
  
      uint8_t num_ref_idx_l0_default_active_minus1;
      uint8_t num_ref_idx_l1_default_active_minus1;
diff --combined libavcodec/cbs_h2645.c
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -31,7 -31,7 +31,7 @@@
  #include "hevc.h"
  
  
 -static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, BitstreamContext *bc,
 +static int cbs_read_ue_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,
                                const char *name, uint32_t *write_to,
                                uint32_t range_min, uint32_t range_max)
  {
      unsigned int k;
      char bits[65];
  
 -    position = bitstream_tell(bc);
 +    position = get_bits_count(gbc);
  
      for (i = 0; i < 32; i++) {
 -        if (bitstream_bits_left(bc) < i + 1) {
 +        if (get_bits_left(gbc) < i + 1) {
              av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid ue-golomb code at "
                     "%s: bitstream ended.\n", name);
              return AVERROR_INVALIDDATA;
          }
 -        k = bitstream_read_bit(bc);
 +        k = get_bits1(gbc);
          bits[i] = k ? '1' : '0';
          if (k)
              break;
@@@ -60,7 -60,7 +60,7 @@@
      }
      value = 1;
      for (j = 0; j < i; j++) {
 -        k = bitstream_read_bit(bc);
 +        k = get_bits1(gbc);
          bits[i + j + 1] = k ? '1' : '0';
          value = value << 1 | k;
      }
@@@ -81,7 -81,7 +81,7 @@@
      return 0;
  }
  
 -static int cbs_read_se_golomb(CodedBitstreamContext *ctx, BitstreamContext *bc,
 +static int cbs_read_se_golomb(CodedBitstreamContext *ctx, GetBitContext *gbc,
                                const char *name, int32_t *write_to,
                                int32_t range_min, int32_t range_max)
  {
      uint32_t v;
      char bits[65];
  
 -    position = bitstream_tell(bc);
 +    position = get_bits_count(gbc);
  
      for (i = 0; i < 32; i++) {
 -        if (bitstream_bits_left(bc) < i + 1) {
 +        if (get_bits_left(gbc) < i + 1) {
              av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid se-golomb code at "
                     "%s: bitstream ended.\n", name);
              return AVERROR_INVALIDDATA;
          }
 -        k = bitstream_read_bit(bc);
 +        k = get_bits1(gbc);
          bits[i] = k ? '1' : '0';
          if (k)
              break;
      }
      v = 1;
      for (j = 0; j < i; j++) {
 -        k = bitstream_read_bit(bc);
 +        k = get_bits1(gbc);
          bits[i + j + 1] = k ? '1' : '0';
          v = v << 1 | k;
      }
@@@ -242,7 -242,7 +242,7 @@@ static int cbs_write_se_golomb(CodedBit
  
  #define READ
  #define READWRITE read
 -#define RWContext BitstreamContext
 +#define RWContext GetBitContext
  
  #define xu(width, name, var, range_min, range_max) do { \
          uint32_t value = range_min; \
          current->name = value; \
      } while (0)
  
 -static int cbs_h2645_read_more_rbsp_data(BitstreamContext *bc)
 +static int cbs_h2645_read_more_rbsp_data(GetBitContext *gbc)
  {
 -    int bits_left = bitstream_bits_left(bc);
 +    int bits_left = get_bits_left(gbc);
      if (bits_left > 8)
          return 1;
 -    if (bitstream_peek(bc, bits_left) == 1 << (bits_left - 1))
 +    if (show_bits(gbc, bits_left) == 1 << (bits_left - 1))
          return 0;
      return 1;
  }
  
  #define more_rbsp_data(var) ((var) = cbs_h2645_read_more_rbsp_data(rw))
  
 -#define byte_alignment(rw) (bitstream_tell(rw) % 8)
 +#define byte_alignment(rw) (get_bits_count(rw) % 8)
  
  #define allocate(name, size) do { \
          name ## _ref = av_buffer_allocz(size); \
  #undef allocate
  
  
+ static void cbs_h264_free_pps(void *unit, uint8_t *content)
+ {
+     H264RawPPS *pps = (H264RawPPS*)content;
+     av_buffer_unref(&pps->slice_group_id_ref);
+     av_freep(&content);
+ }
  static void cbs_h264_free_sei_payload(H264RawSEIPayload *payload)
  {
      switch (payload->payload_type) {
@@@ -481,7 -488,7 +488,7 @@@ static int cbs_h2645_fragment_add_nals(
          memset(data + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  
          err = ff_cbs_insert_unit_data(ctx, frag, -1, nal->type,
 -                                      data, nal->size, NULL);
 +                                      data, size, NULL);
          if (err < 0) {
              av_freep(&data);
              return err;
@@@ -541,7 -548,7 +548,7 @@@ static int cbs_h2645_split_fragment(Cod
  
          err = ff_h2645_packet_split(&priv->read_packet,
                                      frag->data + start, end - start,
 -                                    ctx->log_ctx, 1, 2, AV_CODEC_ID_H264);
 +                                    ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1);
          if (err < 0) {
              av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC SPS array.\n");
              return err;
  
          err = ff_h2645_packet_split(&priv->read_packet,
                                      frag->data + start, end - start,
 -                                    ctx->log_ctx, 1, 2, AV_CODEC_ID_H264);
 +                                    ctx->log_ctx, 1, 2, AV_CODEC_ID_H264, 1);
          if (err < 0) {
              av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split AVCC PPS array.\n");
              return err;
  
              err = ff_h2645_packet_split(&priv->read_packet,
                                          frag->data + start, end - start,
 -                                        ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC);
 +                                        ctx->log_ctx, 1, 2, AV_CODEC_ID_HEVC, 1);
              if (err < 0) {
                  av_log(ctx->log_ctx, AV_LOG_ERROR, "Failed to split "
                         "HVCC array %d (%d NAL units of type %d).\n",
                                      frag->data, frag->data_size,
                                      ctx->log_ctx,
                                      priv->mp4, priv->nal_length_size,
 -                                    codec_id);
 +                                    codec_id, 1);
          if (err < 0)
              return err;
  
@@@ -680,10 -687,10 +687,10 @@@ cbs_h2645_replace_ps(5, PPS, pps, pps_p
  static int cbs_h264_read_nal_unit(CodedBitstreamContext *ctx,
                                    CodedBitstreamUnit *unit)
  {
 -    BitstreamContext bc;
 +    GetBitContext gbc;
      int err;
  
 -    err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
 +    err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
      if (err < 0)
          return err;
  
                  return err;
              sps = unit->content;
  
 -            err = cbs_h264_read_sps(ctx, &bc, sps);
 +            err = cbs_h264_read_sps(ctx, &gbc, sps);
              if (err < 0)
                  return err;
  
              if (err < 0)
                  return err;
  
 -            err = cbs_h264_read_sps_extension(ctx, &bc, unit->content);
 +            err = cbs_h264_read_sps_extension(ctx, &gbc, unit->content);
              if (err < 0)
                  return err;
          }
          {
              H264RawPPS *pps;
  
-             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps), NULL);
+             err = ff_cbs_alloc_unit_content(ctx, unit, sizeof(*pps),
+                                             &cbs_h264_free_pps);
              if (err < 0)
                  return err;
              pps = unit->content;
  
 -            err = cbs_h264_read_pps(ctx, &bc, pps);
 +            err = cbs_h264_read_pps(ctx, &gbc, pps);
              if (err < 0)
                  return err;
  
                  return err;
              slice = unit->content;
  
 -            err = cbs_h264_read_slice_header(ctx, &bc, &slice->header);
 +            err = cbs_h264_read_slice_header(ctx, &gbc, &slice->header);
              if (err < 0)
                  return err;
  
 -            pos = bitstream_tell(&bc);
 +            pos = get_bits_count(&gbc);
              len = unit->data_size;
              if (!unit->data[len - 1]) {
                  int z;
              if (err < 0)
                  return err;
  
 -            err = cbs_h264_read_aud(ctx, &bc, unit->content);
 +            err = cbs_h264_read_aud(ctx, &gbc, unit->content);
              if (err < 0)
                  return err;
          }
              if (err < 0)
                  return err;
  
 -            err = cbs_h264_read_sei(ctx, &bc, unit->content);
 +            err = cbs_h264_read_sei(ctx, &gbc, unit->content);
              if (err < 0)
                  return err;
          }
  static int cbs_h265_read_nal_unit(CodedBitstreamContext *ctx,
                                    CodedBitstreamUnit *unit)
  {
 -    BitstreamContext bc;
 +    GetBitContext gbc;
      int err;
  
 -    err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
 +    err = init_get_bits(&gbc, unit->data, 8 * unit->data_size);
      if (err < 0)
          return err;
  
                  return err;
              vps = unit->content;
  
 -            err = cbs_h265_read_vps(ctx, &bc, vps);
 +            err = cbs_h265_read_vps(ctx, &gbc, vps);
              if (err < 0)
                  return err;
  
                  return err;
              sps = unit->content;
  
 -            err = cbs_h265_read_sps(ctx, &bc, sps);
 +            err = cbs_h265_read_sps(ctx, &gbc, sps);
              if (err < 0)
                  return err;
  
                  return err;
              pps = unit->content;
  
 -            err = cbs_h265_read_pps(ctx, &bc, pps);
 +            err = cbs_h265_read_pps(ctx, &gbc, pps);
              if (err < 0)
                  return err;
  
                  return err;
              slice = unit->content;
  
 -            err = cbs_h265_read_slice_segment_header(ctx, &bc, &slice->header);
 +            err = cbs_h265_read_slice_segment_header(ctx, &gbc, &slice->header);
              if (err < 0)
                  return err;
  
 -            pos = bitstream_tell(&bc);
 +            pos = get_bits_count(&gbc);
              len = unit->data_size;
              if (!unit->data[len - 1]) {
                  int z;
              if (err < 0)
                  return err;
  
 -            err = cbs_h265_read_aud(ctx, &bc, unit->content);
 +            err = cbs_h265_read_aud(ctx, &gbc, unit->content);
              if (err < 0)
                  return err;
          }
@@@ -1008,7 -1016,7 +1016,7 @@@ static int cbs_h264_write_nal_unit(Code
      case H264_NAL_AUXILIARY_SLICE:
          {
              H264RawSlice *slice = unit->content;
 -            BitstreamContext bc;
 +            GetBitContext gbc;
              int bits_left, end, zeroes;
  
              err = cbs_h264_write_slice_header(ctx, pbc, &slice->header);
                  if (slice->data_size * 8 + 8 > put_bits_left(pbc))
                      return AVERROR(ENOSPC);
  
 -                bitstream_init(&bc, slice->data, slice->data_size * 8);
 -                bitstream_skip(&bc, slice->data_bit_start);
 +                init_get_bits(&gbc, slice->data, slice->data_size * 8);
 +                skip_bits_long(&gbc, slice->data_bit_start);
  
                  // Copy in two-byte blocks, but stop before copying the
                  // rbsp_stop_one_bit in the final byte.
 -                while (bitstream_bits_left(&bc) > 23)
 -                    put_bits(pbc, 16, bitstream_read(&bc, 16));
 +                while (get_bits_left(&gbc) > 23)
 +                    put_bits(pbc, 16, get_bits(&gbc, 16));
  
 -                bits_left = bitstream_bits_left(&bc);
 -                end = bitstream_read(&bc, bits_left);
 +                bits_left = get_bits_left(&gbc);
 +                end = get_bits(&gbc, bits_left);
  
                  // rbsp_stop_one_bit must be present here.
                  av_assert0(end);
@@@ -1138,7 -1146,7 +1146,7 @@@ static int cbs_h265_write_nal_unit(Code
      case HEVC_NAL_CRA_NUT:
          {
              H265RawSlice *slice = unit->content;
 -            BitstreamContext bc;
 +            GetBitContext gbc;
              int bits_left, end, zeroes;
  
              err = cbs_h265_write_slice_segment_header(ctx, pbc, &slice->header);
                  if (slice->data_size * 8 + 8 > put_bits_left(pbc))
                      return AVERROR(ENOSPC);
  
 -                bitstream_init(&bc, slice->data, slice->data_size * 8);
 -                bitstream_skip(&bc, slice->data_bit_start);
 +                init_get_bits(&gbc, slice->data, slice->data_size * 8);
 +                skip_bits_long(&gbc, slice->data_bit_start);
  
                  // Copy in two-byte blocks, but stop before copying the
                  // rbsp_stop_one_bit in the final byte.
 -                while (bitstream_bits_left(&bc) > 23)
 -                    put_bits(pbc, 16, bitstream_read(&bc, 16));
 +                while (get_bits_left(&gbc) > 23)
 +                    put_bits(pbc, 16, get_bits(&gbc, 16));
  
 -                bits_left = bitstream_bits_left(&bc);
 -                end = bitstream_read(&bc, bits_left);
 +                bits_left = get_bits_left(&gbc);
 +                end = get_bits(&gbc, bits_left);
  
                  // rbsp_stop_one_bit must be present here.
                  av_assert0(end);
@@@ -1209,7 -1217,7 +1217,7 @@@ static int cbs_h2645_write_nal_unit(Cod
          if (err < 0) {
              av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
                     "sufficiently large write buffer (last attempt "
 -                   "%zu bytes).\n", priv->write_buffer_size);
 +                   "%"SIZE_SPECIFIER" bytes).\n", priv->write_buffer_size);
              return err;
          }
      }
@@@ -1,18 -1,18 +1,18 @@@
  /*
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -404,6 -404,9 +404,9 @@@ static int FUNC(pps)(CodedBitstreamCont
              ue(slice_group_change_rate_minus1, 0, pic_size - 1);
          } else if (current->slice_group_map_type == 6) {
              ue(pic_size_in_map_units_minus1, pic_size - 1, pic_size - 1);
+             allocate(current->slice_group_id,
+                      current->pic_size_in_map_units_minus1 + 1);
              for (i = 0; i <= current->pic_size_in_map_units_minus1; i++)
                  u(av_log2(2 * current->num_slice_groups_minus1 + 1),
                    slice_group_id[i], 0, current->num_slice_groups_minus1);
@@@ -721,7 -724,7 +724,7 @@@ static int FUNC(sei_payload)(CodedBitst
      int start_position, end_position;
  
  #ifdef READ
 -    start_position = bitstream_tell(rw);
 +    start_position = get_bits_count(rw);
  #else
      start_position = put_bits_count(rw);
  #endif
      }
  
  #ifdef READ
 -    end_position = bitstream_tell(rw);
 +    end_position = get_bits_count(rw);
      if (end_position < start_position + 8 * current->payload_size) {
          av_log(ctx->log_ctx, AV_LOG_ERROR, "Incorrect SEI payload length: "
 -               "header %d bits, actually %d bits.\n",
 +               "header %"PRIu32" bits, actually %d bits.\n",
                 8 * current->payload_size,
                 end_position - start_position);
          return AVERROR_INVALIDDATA;
@@@ -806,14 -809,14 +809,14 @@@ static int FUNC(sei)(CodedBitstreamCont
          uint32_t payload_size = 0;
          uint32_t tmp;
  
 -        while (bitstream_peek(rw, 8) == 0xff) {
 +        while (show_bits(rw, 8) == 0xff) {
              xu(8, ff_byte, tmp, 0xff, 0xff);
              payload_type += 255;
          }
          xu(8, last_payload_type_byte, tmp, 0, 254);
          payload_type += tmp;
  
 -        while (bitstream_peek(rw, 8) == 0xff) {
 +        while (show_bits(rw, 8) == 0xff) {
              xu(8, ff_byte, tmp, 0xff, 0xff);
              payload_size += 255;
          }