V1.0.6

packages/artinchip/mpp/ve/encoder/jpeg/put_bits.h

@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2020-2024 ArtInChip Technology Co. Ltd
+ *
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Author: <qi.xu@artinchip.com>
+ * Desc: put bits
+ */
+
+#ifndef __PUT_BITS_H_
+#define __PUT_BITS_H_
+#include <stdlib.h>
+#include <inttypes.h>
+#include <unistd.h>
+#include "mpp_log.h"
+
+static const int BUF_BITS = 8 * sizeof(uint32_t);
+
+struct put_bit_ctx {
+	uint32_t bit_buf;
+	int bit_left;
+	uint8_t *buf, *buf_ptr, *buf_end;
+	int size_in_bits;
+};
+
+static inline void init_put_bits(struct put_bit_ctx *s, uint8_t *buffer, int buffer_size)
+{
+	if (buffer_size < 0) {
+		buffer_size = 0;
+		buffer = NULL;
+		return;
+	}
+
+	s->size_in_bits = 8 * buffer_size;
+	s->buf = buffer;
+	s->buf_end = s->buf + buffer_size;
+	s->buf_ptr = s->buf;
+	s->bit_left = BUF_BITS;
+	s->bit_buf = 0;
+}
+
+static inline int put_bits_count(struct put_bit_ctx *s)
+{
+	return (s->buf_ptr - s->buf) * 8 + BUF_BITS - s->bit_left;
+}
+
+static inline int put_bits_left(struct put_bit_ctx* s)
+{
+	return (s->buf_end - s->buf_ptr) * 8 - BUF_BITS + s->bit_left;
+}
+
+#define AV_BSWAP16C(x) (((x) << 8 & 0xff00)  | ((x) >> 8 & 0x00ff))
+#define AV_BSWAP32C(x) (AV_BSWAP16C(x) << 16 | AV_BSWAP16C((x) >> 16))
+#define AV_WLBUF(p, v) (*((uint64_t *)(p)) = (v))
+#define AV_WBBUF(p, v) (*((uint64_t *)(p)) = (v))
+static inline void put_bits_no_assert(struct put_bit_ctx* s, int n, uint32_t value)
+{
+	uint32_t bit_buf;
+	int bit_left;
+
+	bit_buf = s->bit_buf;
+	bit_left = s->bit_left;
+
+	if (n < bit_left) {
+		bit_buf = (bit_buf << n) | value;
+		bit_left -= n;
+	} else {
+		bit_buf <<= bit_left;
+		bit_buf |= value >> (n - bit_left);
+		if (s->buf_end - s->buf_ptr >= sizeof(uint32_t)) {
+			AV_WBBUF(s->buf_ptr, AV_BSWAP32C(bit_buf));
+			s->buf_ptr += sizeof(uint32_t);
+		} else {
+			loge("Internal error, put_bits buffer too small\n");
+			mpp_assert(0);
+		}
+		bit_left += BUF_BITS - n;
+		bit_buf = value;
+	}
+
+	s->bit_buf = bit_buf;
+	s->bit_left = bit_left;
+}
+
+/**
+* Write up to 31 bits into a bitstream.
+* Use put_bits32 to write 32 bits.
+*/
+static inline void put_bits(struct put_bit_ctx *s, int n, uint32_t value)
+{
+	if(n <= 31 && value < (1UL << n)) {
+		put_bits_no_assert(s, n, value);
+	} else {
+		loge("put bits fail, n: %d, val: 0x%"PRIx32"", n, value);
+	}
+}
+
+static unsigned av_mod_uintp2_c(unsigned a, unsigned p)
+{
+	return a & ((1U << p) - 1);
+}
+
+static inline void put_sbits(struct put_bit_ctx *pb, int n, int32_t value)
+{
+	if (n < 0 || n > 31) {
+		loge("put_sbits error");
+		return;
+	}
+
+	put_bits(pb, n, av_mod_uintp2_c(value, n));
+}
+
+/**
+* Pad the end of the output stream with zeros.
+*/
+static inline void flush_put_bits(struct put_bit_ctx *s)
+{
+	if (s->bit_left < BUF_BITS)
+		s->bit_buf <<= s->bit_left;
+	while (s->bit_left < BUF_BITS) {
+		mpp_assert(s->buf_ptr < s->buf_end);
+		*s->buf_ptr++ = s->bit_buf >> (BUF_BITS - 8);
+		s->bit_buf <<= 8;
+		s->bit_left += 8;
+	}
+	s->bit_left = BUF_BITS;
+	s->bit_buf = 0;
+}
+
+static inline uint8_t *put_bits_ptr(struct put_bit_ctx *s)
+{
+	return s->buf_ptr;
+}
+
+static inline void skip_put_bytes(struct put_bit_ctx *s, int n)
+{
+	mpp_assert((put_bits_count(s) & 7) == 0);
+	mpp_assert(s->bit_left == BUF_BITS);
+	mpp_assert(n <= s->buf_end - s->buf_ptr);
+	s->buf_ptr += n;
+}
+
+#endif