avcodec/h264_sei: Don't use GetBit-API for byte-aligned reads

SEI NALUs and several SEI messages are naturally byte-aligned,
so reading them via the bytestream-API is more natural.

Signed-off-by: Andreas Rheinhardt <andreas.rheinhardt@outlook.com>

2 files changed, 70 insertions, 77 deletions

diff --git a/libavcodec/h264_sei.c b/libavcodec/h264_sei.c
index 034ddb8f1c..d62a276779 100644
--- a/libavcodec/h264_sei.c
+++ b/libavcodec/h264_sei.c
@@ -33,6 +33,7 @@
 #include "libavutil/macros.h"
 #include "libavutil/mem.h"
 #include "atsc_a53.h"
+#include "bytestream.h"
 #include "get_bits.h"
 #include "golomb.h"
 #include "h264_ps.h"
@@ -70,8 +71,10 @@ int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps,
                                        void *logctx)
 {
     GetBitContext gb;
+    av_unused int ret;
 
-    init_get_bits(&gb, h->payload, h->payload_size_bits);
+    ret = init_get_bits8(&gb, h->payload, h->payload_size_bytes);
+    av_assert1(ret >= 0);
 
     if (sps->nal_hrd_parameters_present_flag ||
         sps->vcl_hrd_parameters_present_flag) {
@@ -133,44 +136,36 @@ int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps,
     return 0;
 }
 
-static int decode_picture_timing(H264SEIPictureTiming *h, GetBitContext *gb,
+static int decode_picture_timing(H264SEIPictureTiming *h, GetByteContext *gb,
                                  void *logctx)
 {
-    int index     = get_bits_count(gb);
-    int size_bits = get_bits_left(gb);
-    int size      = (size_bits + 7) / 8;
+    int size = bytestream2_get_bytes_left(gb);
 
-    if (index & 7) {
-        av_log(logctx, AV_LOG_ERROR, "Unaligned SEI payload\n");
-        return AVERROR_INVALIDDATA;
-    }
     if (size > sizeof(h->payload)) {
         av_log(logctx, AV_LOG_ERROR, "Picture timing SEI payload too large\n");
         return AVERROR_INVALIDDATA;
     }
-    memcpy(h->payload, gb->buffer + index / 8, size);
+    bytestream2_get_bufferu(gb, h->payload, size);
 
-    h->payload_size_bits = size_bits;
+    h->payload_size_bytes = size;
 
     h->present = 1;
     return 0;
 }
 
-static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int size)
+static int decode_registered_user_data_afd(H264SEIAFD *h, GetByteContext *gb)
 {
     int flag;
 
-    if (size-- < 1)
+    if (bytestream2_get_bytes_left(gb) <= 0)
         return AVERROR_INVALIDDATA;
-    skip_bits(gb, 1);               // 0
-    flag = get_bits(gb, 1);         // active_format_flag
-    skip_bits(gb, 6);               // reserved
+
+    flag = !!(bytestream2_get_byteu(gb) & 0x40); // active_format_flag
 
     if (flag) {
-        if (size-- < 1)
+        if (bytestream2_get_bytes_left(gb) <= 0)
             return AVERROR_INVALIDDATA;
-        skip_bits(gb, 4);           // reserved
-        h->active_format_description = get_bits(gb, 4);
+        h->active_format_description = bytestream2_get_byteu(gb) & 0xF;
         h->present                   = 1;
     }
 
@@ -178,31 +173,26 @@ static int decode_registered_user_data_afd(H264SEIAFD *h, GetBitContext *gb, int
 }
 
 static int decode_registered_user_data_closed_caption(H264SEIA53Caption *h,
-                                                     GetBitContext *gb, void *logctx,
-                                                     int size)
+                                                      GetByteContext *gb)
 {
-    if (size < 3)
-        return AVERROR(EINVAL);
-
-    return ff_parse_a53_cc(&h->buf_ref, gb->buffer + get_bits_count(gb) / 8, size);
+    return ff_parse_a53_cc(&h->buf_ref, gb->buffer,
+                           bytestream2_get_bytes_left(gb));
 }
 
-static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,
-                                       void *logctx, int size)
+static int decode_registered_user_data(H264SEIContext *h, GetByteContext *gb,
+                                       void *logctx)
 {
     int country_code, provider_code;
 
-    if (size < 3)
+    if (bytestream2_get_bytes_left(gb) < 3)
         return AVERROR_INVALIDDATA;
-    size -= 3;
 
-    country_code = get_bits(gb, 8); // itu_t_t35_country_code
+    country_code = bytestream2_get_byteu(gb); // itu_t_t35_country_code
     if (country_code == 0xFF) {
-        if (size < 1)
+        if (bytestream2_get_bytes_left(gb) < 3)
             return AVERROR_INVALIDDATA;
 
-        skip_bits(gb, 8);           // itu_t_t35_country_code_extension_byte
-        size--;
+        bytestream2_skipu(gb, 1);  // itu_t_t35_country_code_extension_byte
     }
 
     if (country_code != 0xB5) { // usa_country_code
@@ -213,23 +203,21 @@ static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,
     }
 
     /* itu_t_t35_payload_byte follows */
-    provider_code = get_bits(gb, 16);
+    provider_code = bytestream2_get_be16u(gb);
 
     switch (provider_code) {
     case 0x31: { // atsc_provider_code
         uint32_t user_identifier;
 
-        if (size < 4)
+        if (bytestream2_get_bytes_left(gb) < 4)
             return AVERROR_INVALIDDATA;
-        size -= 4;
 
-        user_identifier = get_bits_long(gb, 32);
+        user_identifier = bytestream2_get_be32u(gb);
         switch (user_identifier) {
         case MKBETAG('D', 'T', 'G', '1'):       // afd_data
-            return decode_registered_user_data_afd(&h->afd, gb, size);
+            return decode_registered_user_data_afd(&h->afd, gb);
         case MKBETAG('G', 'A', '9', '4'):       // closed captions
-            return decode_registered_user_data_closed_caption(&h->a53_caption, gb,
-                                                              logctx, size);
+            return decode_registered_user_data_closed_caption(&h->a53_caption, gb);
         default:
             av_log(logctx, AV_LOG_VERBOSE,
                    "Unsupported User Data Registered ITU-T T35 SEI message (atsc user_identifier = 0x%04x)\n",
@@ -248,11 +236,11 @@ static int decode_registered_user_data(H264SEIContext *h, GetBitContext *gb,
     return 0;
 }
 
-static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *gb,
-                                         void *logctx, int size)
+static int decode_unregistered_user_data(H264SEIUnregistered *h, GetByteContext *gb,
+                                         void *logctx)
 {
     uint8_t *user_data;
-    int e, build, i;
+    int e, build, size = bytestream2_get_bytes_left(gb);
     AVBufferRef *buf_ref, **tmp;
 
     if (size < 16 || size >= INT_MAX - 1)
@@ -268,10 +256,8 @@ static int decode_unregistered_user_data(H264SEIUnregistered *h, GetBitContext *
         return AVERROR(ENOMEM);
     user_data = buf_ref->data;
 
-    for (i = 0; i < size; i++)
-        user_data[i] = get_bits(gb, 8);
-
-    user_data[i] = 0;
+    bytestream2_get_bufferu(gb, user_data, size);
+    user_data[size] = 0;
     buf_ref->size = size;
     h->buf_ref[h->nb_buf_ref++] = buf_ref;
 
@@ -384,36 +370,36 @@ static int decode_display_orientation(H264SEIDisplayOrientation *h,
     return 0;
 }
 
-static int decode_green_metadata(H264SEIGreenMetaData *h, GetBitContext *gb)
+static int decode_green_metadata(H264SEIGreenMetaData *h, GetByteContext *gb)
 {
-    h->green_metadata_type = get_bits(gb, 8);
+    h->green_metadata_type = bytestream2_get_byte(gb);
 
     if (h->green_metadata_type == 0) {
-        h->period_type = get_bits(gb, 8);
+        h->period_type = bytestream2_get_byte(gb);
 
         if (h->period_type == 2)
-            h->num_seconds = get_bits(gb, 16);
+            h->num_seconds = bytestream2_get_be16(gb);
         else if (h->period_type == 3)
-            h->num_pictures = get_bits(gb, 16);
+            h->num_pictures = bytestream2_get_be16(gb);
 
-        h->percent_non_zero_macroblocks            = get_bits(gb, 8);
-        h->percent_intra_coded_macroblocks         = get_bits(gb, 8);
-        h->percent_six_tap_filtering               = get_bits(gb, 8);
-        h->percent_alpha_point_deblocking_instance = get_bits(gb, 8);
+        h->percent_non_zero_macroblocks            = bytestream2_get_byte(gb);
+        h->percent_intra_coded_macroblocks         = bytestream2_get_byte(gb);
+        h->percent_six_tap_filtering               = bytestream2_get_byte(gb);
+        h->percent_alpha_point_deblocking_instance = bytestream2_get_byte(gb);
 
     } else if (h->green_metadata_type == 1) {
-        h->xsd_metric_type  = get_bits(gb, 8);
-        h->xsd_metric_value = get_bits(gb, 16);
+        h->xsd_metric_type  = bytestream2_get_byte(gb);
+        h->xsd_metric_value = bytestream2_get_be16(gb);
     }
 
     return 0;
 }
 
 static int decode_alternative_transfer(H264SEIAlternativeTransfer *h,
-                                       GetBitContext *gb)
+                                       GetByteContext *gb)
 {
     h->present = 1;
-    h->preferred_transfer_characteristics = get_bits(gb, 8);
+    h->preferred_transfer_characteristics = bytestream2_get_byte(gb);
     return 0;
 }
 
@@ -463,45 +449,52 @@ static int decode_film_grain_characteristics(H264SEIFilmGrainCharacteristics *h,
 int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
                        const H264ParamSets *ps, void *logctx)
 {
+    GetByteContext gbyte;
     int master_ret = 0;
 
-    while (get_bits_left(gb) > 16 && show_bits(gb, 16)) {
+    av_assert1((get_bits_count(gb) % 8) == 0);
+    bytestream2_init(&gbyte, gb->buffer + get_bits_count(gb) / 8,
+                     get_bits_left(gb) / 8);
+
+    while (bytestream2_get_bytes_left(&gbyte) > 2 && bytestream2_peek_ne16(&gbyte)) {
+        GetByteContext gbyte_payload;
         GetBitContext gb_payload;
         int type = 0;
         unsigned size = 0;
         int ret  = 0;
 
         do {
-            if (get_bits_left(gb) < 8)
+            if (bytestream2_get_bytes_left(&gbyte) <= 0)
                 return AVERROR_INVALIDDATA;
-            type += show_bits(gb, 8);
-        } while (get_bits(gb, 8) == 255);
+            type += bytestream2_peek_byteu(&gbyte);
+        } while (bytestream2_get_byteu(&gbyte) == 255);
 
         do {
-            if (get_bits_left(gb) < 8)
+            if (bytestream2_get_bytes_left(&gbyte) <= 0)
                 return AVERROR_INVALIDDATA;
-            size += show_bits(gb, 8);
-        } while (get_bits(gb, 8) == 255);
+            size += bytestream2_peek_byteu(&gbyte);
+        } while (bytestream2_get_byteu(&gbyte) == 255);
 
-        if (size > get_bits_left(gb) / 8) {
+        if (size > bytestream2_get_bytes_left(&gbyte)) {
             av_log(logctx, AV_LOG_ERROR, "SEI type %d size %d truncated at %d\n",
-                   type, 8*size, get_bits_left(gb));
+                   type, size, bytestream2_get_bytes_left(&gbyte));
             return AVERROR_INVALIDDATA;
         }
 
-        ret = init_get_bits8(&gb_payload, gb->buffer + get_bits_count(gb) / 8, size);
+        bytestream2_init (&gbyte_payload, gbyte.buffer, size);
+        ret = init_get_bits8(&gb_payload, gbyte.buffer, size);
         if (ret < 0)
             return ret;
 
         switch (type) {
         case SEI_TYPE_PIC_TIMING: // Picture timing SEI
-            ret = decode_picture_timing(&h->picture_timing, &gb_payload, logctx);
+            ret = decode_picture_timing(&h->picture_timing, &gbyte_payload, logctx);
             break;
         case SEI_TYPE_USER_DATA_REGISTERED_ITU_T_T35:
-            ret = decode_registered_user_data(h, &gb_payload, logctx, size);
+            ret = decode_registered_user_data(h, &gbyte_payload, logctx);
             break;
         case SEI_TYPE_USER_DATA_UNREGISTERED:
-            ret = decode_unregistered_user_data(&h->unregistered, &gb_payload, logctx, size);
+            ret = decode_unregistered_user_data(&h->unregistered, &gbyte_payload, logctx);
             break;
         case SEI_TYPE_RECOVERY_POINT:
             ret = decode_recovery_point(&h->recovery_point, &gb_payload, logctx);
@@ -516,10 +509,10 @@ int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
             ret = decode_display_orientation(&h->display_orientation, &gb_payload);
             break;
         case SEI_TYPE_GREEN_METADATA:
-            ret = decode_green_metadata(&h->green_metadata, &gb_payload);
+            ret = decode_green_metadata(&h->green_metadata, &gbyte_payload);
             break;
         case SEI_TYPE_ALTERNATIVE_TRANSFER_CHARACTERISTICS:
-            ret = decode_alternative_transfer(&h->alternative_transfer, &gb_payload);
+            ret = decode_alternative_transfer(&h->alternative_transfer, &gbyte_payload);
             break;
         case SEI_TYPE_FILM_GRAIN_CHARACTERISTICS:
             ret = decode_film_grain_characteristics(&h->film_grain_characteristics, &gb_payload);
@@ -537,7 +530,7 @@ int ff_h264_sei_decode(H264SEIContext *h, GetBitContext *gb,
                    type, -get_bits_left(&gb_payload));
         }
 
-        skip_bits_long(gb, 8 * size);
+        bytestream2_skipu(&gbyte, size);
     }
 
     return master_ret;
diff --git a/libavcodec/h264_sei.h b/libavcodec/h264_sei.h
index f9166b45df..d7866f42ad 100644
--- a/libavcodec/h264_sei.h
+++ b/libavcodec/h264_sei.h
@@ -66,7 +66,7 @@ typedef struct H264SEITimeCode {
 typedef struct H264SEIPictureTiming {
     // maximum size of pic_timing according to the spec should be 274 bits
     uint8_t payload[40];
-    int     payload_size_bits;
+    int     payload_size_bytes;
 
     int present;
     H264_SEI_PicStructType pic_struct;