API tools faq
paste
Advertisement
Guest User

Untitled

a guest
Jun 6th, 2019
42
0
Never
Add comment
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
Diff 7.06 KB | None | 0 0
raw download clone embed print report
  1. diff --git a/libavcodec/cbs_av1.c b/libavcodec/cbs_av1.c
  2. index 3581285a47..b82b153cc9 100644
  3. --- a/libavcodec/cbs_av1.c
  4. +++ b/libavcodec/cbs_av1.c
  5. @@ -777,8 +777,9 @@ static int cbs_av1_get_relative_dist(const AV1RawSequenceHeader *seq,
  6.  
  7.  
  8.  typedef int (*cbs_av1_split_obu_callback)(CodedBitstreamContext *ctx,
  9. -                                          void *priv, int obu_type,
  10. -                                          const uint8_t *data, size_t size);
  11. +                                          void *priv, AV1RawOBUHeader *header,
  12. +                                          const uint8_t *data, size_t size,
  13. +                                          ptrdiff_t offset);
  14.  
  15.  static int cbs_av1_split_obus(CodedBitstreamContext *ctx,
  16.                                void *priv, cbs_av1_split_obu_callback cb,
  17. @@ -836,7 +837,7 @@ static int cbs_av1_split_obus(CodedBitstreamContext *ctx,
  18.              goto fail;
  19.          }
  20.  
  21. -        err = cb(ctx, priv, header.obu_type, data, obu_length);
  22. +        err = cb(ctx, priv, &header, data, obu_length, pos / 8);
  23.          if (err < 0)
  24.              goto fail;
  25.  
  26. @@ -851,11 +852,12 @@ fail:
  27.  }
  28.  
  29.  static int cbs_av1_insert_obu(CodedBitstreamContext *ctx,
  30. -                              void *priv, int obu_type,
  31. -                              const uint8_t *data, size_t size)
  32. +                              void *priv, AV1RawOBUHeader *header,
  33. +                              const uint8_t *data, size_t size,
  34. +                              ptrdiff_t offset)
  35.  {
  36.      CodedBitstreamFragment *frag = priv;
  37. -    return ff_cbs_insert_unit_data(ctx, frag, -1, obu_type,
  38. +    return ff_cbs_insert_unit_data(ctx, frag, -1, header->obu_type,
  39.                                     (uint8_t*)data, size, frag->data_ref);
  40.  }
  41.  
  42. @@ -910,11 +912,7 @@ static int cbs_av1_ref_tile_data(CodedBitstreamContext *ctx,
  43.  {
  44.      int pos;
  45.  
  46. -    if (!unit->data_ref) {
  47. -        // Not refcounted - only parsing headers, so tile data will
  48. -        // not be needed.
  49. -        return 0;
  50. -    }
  51. +    av_assert0(unit->data_ref);
  52.  
  53.      pos = get_bits_count(gbc);
  54.      if (pos >= 8 * unit->data_size) {
  55. @@ -1346,43 +1344,113 @@ static void cbs_av1_close(CodedBitstreamContext *ctx)
  56.  }
  57.  
  58.  static int cbs_av1_parse_obu(CodedBitstreamContext *ctx,
  59. -                             void *priv, int obu_type,
  60. -                             const uint8_t *data, size_t data_size)
  61. +                             void *priv, AV1RawOBUHeader *header,
  62. +                             const uint8_t *data, size_t data_size,
  63. +                             ptrdiff_t offset)
  64.  {
  65. -    CodedBitstreamUnit unit;
  66. +    CodedBitstreamAV1Context *av1 = ctx->priv_data;
  67. +    GetBitContext gbc;
  68.      int err;
  69.  
  70.      // These OBU types will not affect parsing.
  71. -    if (obu_type == AV1_OBU_METADATA  ||
  72. -        obu_type == AV1_OBU_TILE_LIST ||
  73. -        obu_type == AV1_OBU_PADDING)
  74. +    if (header->obu_type == AV1_OBU_METADATA  ||
  75. +        header->obu_type == AV1_OBU_TILE_LIST ||
  76. +        header->obu_type == AV1_OBU_PADDING)
  77.          return 0;
  78.  
  79. -    unit = (CodedBitstreamUnit) {
  80. -        .type      = obu_type,
  81. -        .data      = (uint8_t*)data,
  82. -        .data_size = data_size,
  83. -    };
  84. -
  85. -    err = cbs_av1_read_unit(ctx, &unit);
  86. -    if (err >= 0 && priv) {
  87. -        AV1RawOBU *obu = unit.content;
  88. -        switch (obu->header.obu_type) {
  89. -        case AV1_OBU_FRAME_HEADER:
  90. -        case AV1_OBU_REDUNDANT_FRAME_HEADER:
  91. -            memcpy(priv, &obu->obu.frame_header,
  92. -                   sizeof(obu->obu.frame_header));
  93. -            break;
  94. -        case AV1_OBU_FRAME:
  95. -            memcpy(priv, &obu->obu.frame.header,
  96. -                   sizeof(obu->obu.frame.header));
  97. -            break;
  98. +    err = init_get_bits8(&gbc, data + offset, data_size - offset);
  99. +    if (err < 0)
  100. +        return err;
  101. +
  102. +    if (header->obu_extension_flag) {
  103. +        av1->temporal_id = header->temporal_id;
  104. +        av1->spatial_id  = header->spatial_id;
  105. +
  106. +        if (header->obu_type != AV1_OBU_SEQUENCE_HEADER &&
  107. +            header->obu_type != AV1_OBU_TEMPORAL_DELIMITER &&
  108. +            av1->operating_point_idc) {
  109. +            int in_temporal_layer =
  110. +                (av1->operating_point_idc >>  av1->temporal_id    ) & 1;
  111. +            int in_spatial_layer  =
  112. +                (av1->operating_point_idc >> (av1->spatial_id + 8)) & 1;
  113. +            if (!in_temporal_layer || !in_spatial_layer) {
  114. +                // Decoding will drop this OBU at this operating point.
  115. +            }
  116.          }
  117. +    } else {
  118. +        av1->temporal_id = 0;
  119. +        av1->spatial_id  = 0;
  120.      }
  121.  
  122. -    av_buffer_unref(&unit.content_ref);
  123. +    switch (header->obu_type) {
  124. +    case AV1_OBU_SEQUENCE_HEADER:
  125. +        {
  126. +            AV1RawSequenceHeader *sequence_header;
  127. +            AVBufferRef *sequence_header_ref = av_buffer_allocz(sizeof(AV1RawSequenceHeader));
  128.  
  129. -    return err;
  130. +            if (!sequence_header_ref)
  131. +                return AVERROR(ENOMEM);
  132. +            sequence_header = (AV1RawSequenceHeader *)sequence_header_ref->data;
  133. +
  134. +            err = cbs_av1_read_sequence_header_obu(ctx, &gbc, sequence_header);
  135. +            if (err < 0) {
  136. +                av_buffer_unref(&sequence_header_ref);
  137. +                return err;
  138. +            }
  139. +
  140. +            av_buffer_unref(&av1->sequence_header_ref);
  141. +            av1->sequence_header_ref = sequence_header_ref;
  142. +            av1->sequence_header = sequence_header;
  143. +        }
  144. +        break;
  145. +    case AV1_OBU_TEMPORAL_DELIMITER:
  146. +        {
  147. +            err = cbs_av1_read_temporal_delimiter_obu(ctx, &gbc);
  148. +            if (err < 0)
  149. +                return err;
  150. +        }
  151. +        break;
  152. +    case AV1_OBU_FRAME_HEADER:
  153. +    case AV1_OBU_REDUNDANT_FRAME_HEADER:
  154. +        {
  155. +            AV1RawFrameHeader frame_header = { 0 };
  156. +
  157. +            err = cbs_av1_read_frame_header_obu(ctx, &gbc,
  158. +                                                &frame_header,
  159. +                                                header->obu_type ==
  160. +                                                AV1_OBU_REDUNDANT_FRAME_HEADER,
  161. +                                                NULL);
  162. +            if (err < 0)
  163. +                return err;
  164. +            if (frame_header.show_frame || frame_header.show_existing_frame)
  165. +                memcpy(priv, &frame_header, sizeof(frame_header));
  166. +        }
  167. +        break;
  168. +    case AV1_OBU_TILE_GROUP:
  169. +        {
  170. +            AV1RawTileGroup tile_group = { 0 };
  171. +
  172. +            err = cbs_av1_read_tile_group_obu(ctx, &gbc, &tile_group);
  173. +            if (err < 0)
  174. +                return err;
  175. +        }
  176. +        break;
  177. +    case AV1_OBU_FRAME:
  178. +        {
  179. +            AV1RawFrame frame = { 0 };
  180. +
  181. +            err = cbs_av1_read_frame_obu(ctx, &gbc, &frame, NULL);
  182. +            if (err < 0)
  183. +                return err;
  184. +            if (frame.header.show_frame)
  185. +                memcpy(priv, &frame.header, sizeof(frame.header));
  186. +        }
  187. +        break;
  188. +    default:
  189. +        return AVERROR(ENOSYS);
  190. +    }
  191. +
  192. +    return 0;
  193.  }
  194.  
  195.  static int cbs_av1_parse_headers(CodedBitstreamContext *ctx, void *header,
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement
Public Pastes
Advertisement
We use cookies for various purposes including analytics. By continuing to use Pastebin, you agree to our use of cookies as described in the Cookies Policy.  OK, I Understand
Not a member of Pastebin yet?
Sign Up, it unlocks many cool features!