Reads packets (access units) by breaking constituent NAL units into
structures containing all syntax elements. Writes packets by
reconstructing the stream from the syntax element structures.
---
libavcodec/h264_raw.c | 777 ++++++++++++++++++++++
libavcodec/h264_raw.h | 439 +++++++++++++
libavcodec/h264_raw_syntax.c | 1476 ++++++++++++++++++++++++++++++++++++++++++
libavcodec/h264_sei.h | 1 +
4 files changed, 2693 insertions(+)
create mode 100644 libavcodec/h264_raw.c
create mode 100644 libavcodec/h264_raw.h
create mode 100644 libavcodec/h264_raw_syntax.c
diff --git a/libavcodec/h264_raw.c b/libavcodec/h264_raw.c
new file mode 100644
index 000000000..8f840a54a
--- /dev/null
+++ b/libavcodec/h264_raw.c
@@ -0,0 +1,777 @@
+/*
+ * This file is part of Libav.
+ *
+ * Libav 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "libavutil/avassert.h"
+#include "libavutil/common.h"
+#include "libavutil/intmath.h"
+
+#include "avcodec.h"
+#include "bitstream.h"
+#include "bytestream.h"
+#include "golomb.h"
+#include "h264.h"
+#include "h264_sei.h"
+#include "h264_raw.h"
+#include "h2645_parse.h"
+#include "put_bits.h"
+
+
+static void h264_raw_trace_header(H264RawContext *ctx,
+ const char *name)
+{
+ if (ctx->trace_callback)
+ ctx->trace_callback(ctx->trace_callback_context,
+ 1, "%s\n", name);
+ else
+ av_log(ctx, ctx->trace_level, "========== %s\n", name);
+}
+
+static void h264_raw_trace(H264RawContext *ctx, int position,
+ const char *name, const char *bits,
+ int64_t value)
+{
+ size_t name_len, bits_len;
+ int pad;
+
+ av_assert0(value >= INT_MIN && value <= UINT32_MAX);
+
+ name_len = strlen(name);
+ bits_len = strlen(bits);
+
+ if (name_len + bits_len > 60)
+ pad = bits_len + 2;
+ else
+ pad = 61 - name_len;
+
+ if (ctx->trace_callback) {
+ ctx->trace_callback(ctx->trace_callback_context,
+ 0, "%-10d %s%*s = %"PRId64"\n",
+ position, name, pad, bits, value);
+ } else {
+ av_log(ctx, ctx->trace_level, "%-10d %s%*s = %"PRId64"\n",
+ position, name, pad, bits, value);
+ }
+}
+
+#define READ
+#include "h264_raw_syntax.c"
+#undef READ
+
+#define WRITE
+#include "h264_raw_syntax.c"
+#undef WRITE
+
+
+static int h264_raw_replace_sps(H264RawContext *ctx,
+ const H264RawSPS *sps)
+{
+ int id = sps->seq_parameter_set_id;
+ if (id > FF_ARRAY_ELEMS(ctx->sps)) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid SPS id: %d.\n", id);
+ return AVERROR_INVALIDDATA;
+ }
+ av_freep(&ctx->sps[id]);
+ ctx->sps[id] = av_malloc(sizeof(*sps));
+ if (!ctx->sps[id])
+ return AVERROR(ENOMEM);
+ memcpy(ctx->sps[id], sps, sizeof(*sps));
+ return 0;
+}
+
+static int h264_raw_replace_pps(H264RawContext *ctx,
+ const H264RawPPS *pps)
+{
+ int id = pps->seq_parameter_set_id;
+ if (id > FF_ARRAY_ELEMS(ctx->pps)) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid PPS id: %d.\n", id);
+ return AVERROR_INVALIDDATA;
+ }
+ av_freep(&ctx->pps[id]);
+ ctx->pps[id] = av_malloc(sizeof(*pps));
+ if (!ctx->pps[id])
+ return AVERROR(ENOMEM);
+ memcpy(ctx->pps[id], pps, sizeof(*pps));
+ return 0;
+}
+
+static int h264_raw_read_nal_unit(H264RawContext *ctx,
+ H264RawNALUnit *nal,
+ const uint8_t *data, int size)
+{
+ BitstreamContext bc;
+ int err;
+
+ err = bitstream_init(&bc, data, 8 * size);
+ if (err < 0)
+ goto fail;
+
+ switch (nal->type) {
+ case H264_NAL_SPS:
+ {
+ nal->sps = av_mallocz(sizeof(*nal->sps));
+ if (!nal->sps) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = h264_raw_read_sps(ctx, &bc, nal->sps);
+ if (err < 0)
+ goto fail;
+ h264_raw_replace_sps(ctx, nal->sps);
+ }
+ break;
+ case H264_NAL_PPS:
+ {
+ nal->pps = av_mallocz(sizeof(*nal->pps));
+ if (!nal->sps) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = h264_raw_read_pps(ctx, &bc, nal->pps);
+ if (err < 0)
+ goto fail;
+ h264_raw_replace_pps(ctx, nal->pps);
+ }
+ break;
+ case H264_NAL_SLICE:
+ case H264_NAL_IDR_SLICE:
+ {
+ int pos, len;
+
+ nal->slice.header = av_mallocz(sizeof(*nal->slice.header));
+ if (!nal->slice.header) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = h264_raw_read_slice_header(ctx, &bc,
+ nal->slice.header);
+ if (err < 0)
+ goto fail;
+
+ pos = bitstream_tell(&bc);
+ len = (8 * size - pos + 7) / 8;
+
+ nal->slice.data = av_malloc(len);
+ if (!nal->slice.data) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ memcpy(nal->slice.data, data + pos / 8, len);
+ if (!nal->slice.data[len - 1]) {
+ int z;
+ for (z = 0; z < len && !nal->slice.data[len - z - 1]; z++);
+ av_log(ctx, AV_LOG_DEBUG, "Deleted %d trailing zeroes "
+ "from slice data.\n", z);
+ len -= z;
+ }
+
+ nal->slice.data_length = len;
+ nal->slice.data_bit_start = pos % 8;
+ }
+ break;
+ case H264_NAL_AUD:
+ {
+ nal->aud = av_mallocz(sizeof(*nal->aud));
+ if (!nal->aud) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = h264_raw_read_aud(ctx, &bc, nal->aud);
+ if (err < 0)
+ goto fail;
+ }
+ break;
+ case H264_NAL_SEI:
+ {
+ nal->sei = av_mallocz(sizeof(*nal->sei));
+ if (!nal->sei) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ err = h264_raw_read_sei(ctx, &bc, nal->sei);
+ if (err < 0)
+ goto fail;
+ }
+ break;
+ default:
+ {
+ nal->other.data = av_malloc(size);
+ if (!nal->other.data) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+ memcpy(nal->other.data, data, size);
+ nal->other.data_length = size;
+ }
+ break;
+ }
+
+ return 0;
+fail:
+ return err;
+}
+
+static int h264_raw_read_nal_unit_escaped(H264RawContext *ctx,
+ H264RawNALUnit *nal,
+ const uint8_t *data, int size)
+{
+ uint8_t *rbsp;
+ int err, i, j;
+
+ rbsp = av_malloc(size * 3 / 2);
+ if (!rbsp)
+ return AVERROR(ENOMEM);
+
+ for (i = j = 0; i < size;) {
+ if (i < size - 2 && data[i] == 0x00 &&
+ data[i+1] == 0x00 && data[i+2] == 0x03) {
+ rbsp[j] = 0x00;
+ rbsp[j+1] = 0x00;
+ i += 3;
+ j += 2;
+ } else {
+ rbsp[j++] = data[i++];
+ }
+ }
+
+ err = h264_raw_read_nal_unit(ctx, nal, rbsp, j);
+ av_free(rbsp);
+ return err;
+}
+
+int ff_h264_raw_read_extradata(H264RawContext *ctx,
+ H264RawAccessUnit *au,
+ const AVCodecParameters *par)
+{
+ int err;
+
+ if (par->extradata_size < 7) {
+ av_log(ctx, AV_LOG_ERROR, "Extradata too short.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (par->extradata[0]) {
+ // AVCC.
+ GetByteContext gbc;
+ H264RawNALUnit *nal;
+ int version, count, length, i;
+
+ ctx->avcc = 1;
+
+ bytestream2_init(&gbc, par->extradata,
+ par->extradata_size);
+
+ version = bytestream2_get_byte(&gbc);
+ if (version != 1) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid extradata: "
+ "first byte %u.", version);
+ return AVERROR_INVALIDDATA;
+ }
+ bytestream2_skip(&gbc, 3);
+
+ ctx->nal_length_size = (bytestream2_get_byte(&gbc) & 3) + 1;
+
+ count = bytestream2_get_byte(&gbc) & 0x1f;
+
+ au->nb_nal_units = 0;
+ au->nal_units = av_mallocz_array(count, sizeof(*au->nal_units));
+ if (!au->nal_units)
+ return AVERROR(ENOMEM);
+
+ for (i = 0; i < count; i++) {
+ length = bytestream2_get_be16(&gbc);
+ if (bytestream2_get_bytes_left(&gbc) < length) {
+ av_log(ctx, AV_LOG_ERROR, "Truncated extradata"
+ " (at SPS %d).\n", i);
+ return AVERROR_INVALIDDATA;
+ }
+
+ nal = &au->nal_units[au->nb_nal_units++];
+ nal->type = H264_NAL_SPS;
+
+ err = h264_raw_read_nal_unit_escaped(ctx, nal, gbc.buffer, length);
+ if (err < 0)
+ return err;
+
+ bytestream2_skip(&gbc, length);
+ }
+
+ au->nb_nal_units = count;
+
+ count = bytestream2_get_byte(&gbc);
+
+ err = av_reallocp_array(&au->nal_units,
+ au->nb_nal_units + count,
+ sizeof(*au->nal_units));
+ if (!au->nal_units)
+ return AVERROR(ENOMEM);
+ memset(au->nal_units + au->nb_nal_units, 0,
+ count * sizeof(*au->nal_units));
+
+ for (i = 0; i < count; i++) {
+ length = bytestream2_get_be16(&gbc);
+ if (bytestream2_get_bytes_left(&gbc) < length) {
+ av_log(ctx, AV_LOG_ERROR, "Truncated extradata"
+ " (at PPS %d).\n", i);
+ return AVERROR_INVALIDDATA;
+ }
+
+ nal = &au->nal_units[au->nb_nal_units++];
+ nal->type = H264_NAL_PPS;
+
+ err = h264_raw_read_nal_unit_escaped(ctx, nal, gbc.buffer, length);
+ if (err < 0)
+ return err;
+
+ bytestream2_skip(&gbc, length);
+ }
+
+ } else {
+ // Annex B.
+ H2645Packet packet = { 0 };
+ int i;
+
+ ctx->avcc = 0;
+
+ err = ff_h2645_packet_split(&packet, par->extradata,
+ par->extradata_size, ctx, 0, 0,
+ AV_CODEC_ID_H264);
+ if (err < 0)
+ goto fail;
+
+ au->nb_nal_units = packet.nb_nals;
+ au->nal_units = av_mallocz_array(au->nb_nal_units,
+ sizeof(*au->nal_units));
+ if (!au->nal_units) {
+ err = AVERROR(ENOMEM);
+ goto fail;
+ }
+
+ for (i = 0; i < packet.nb_nals; i++) {
+ H2645NAL *split_nal = &packet.nals[i];
+ H264RawNALUnit *nal = &au->nal_units[i];
+
+ nal->type = split_nal->type;
+
+ err = h264_raw_read_nal_unit(ctx, nal, split_nal->data,
+ split_nal->size);
+ if (err < 0)
+ goto fail;
+ }
+ }
+
+ return 0;
+fail:
+ return err;
+}
+
+int ff_h264_raw_read_packet(H264RawContext *ctx,
+ H264RawAccessUnit *au,
+ const AVPacket *avpkt)
+{
+ H2645Packet packet = { 0 };
+ int err, i;
+
+ err = ff_h2645_packet_split(&packet, avpkt->data, avpkt->size,
+ ctx, ctx->avcc, ctx->nal_length_size,
+ AV_CODEC_ID_H264);
+ if (err < 0)
+ return err;
+
+ au->nb_nal_units = packet.nb_nals;
+ au->nal_units = av_mallocz_array(au->nb_nal_units,
+ sizeof(*au->nal_units));
+ if (!au->nal_units)
+ goto fail;
+
+ for (i = 0; i < packet.nb_nals; i++) {
+ H2645NAL *split_nal = &packet.nals[i];
+ H264RawNALUnit *nal = &au->nal_units[i];
+
+ nal->type = split_nal->type;
+
+ err = h264_raw_read_nal_unit(ctx, nal, split_nal->data,
+ split_nal->size);
+ if (err < 0)
+ goto fail;
+ }
+
+ ff_h2645_packet_uninit(&packet);
+
+ return 0;
+
+fail:
+ return err;
+}
+
+static int h264_raw_write_emulation_prevention(uint8_t *dst, size_t
*dst_bit_len,
+ uint8_t *src, size_t
src_bit_len)
+{
+ size_t dp, sp;
+ int zero_run = 0;
+ size_t dst_len = *dst_bit_len / 8;
+ size_t src_len = (src_bit_len + 7) / 8;
+ int trailing_zeroes = src_len * 8 - src_bit_len;
+
+ if (dst_len < src_len + 4) {
+ // Definitely doesn't fit.
+ goto fail;
+ }
+
+ // Start code.
+ dst[0] = dst[1] = dst[2] = 0;
+ dst[3] = 1;
+ dp = 4;
+
+ for (sp = 0; sp < src_len; sp++) {
+ if (dp >= dst_len)
+ goto fail;
+ if (zero_run < 2) {
+ if (src[sp] == 0)
+ ++zero_run;
+ else
+ zero_run = 0;
+ } else {
+ if ((src[sp] & ~3) == 0) {
+ // emulation_prevention_three_byte
+ dst[dp++] = 3;
+ if (dp >= dst_len)
+ goto fail;
+ }
+ zero_run = src[sp] == 0;
+ }
+ dst[dp++] = src[sp];
+ }
+
+ *dst_bit_len = 8 * dp - trailing_zeroes;
+ return 0;
+
+fail:
+ *dst_bit_len = 0;
+ return AVERROR(ENOSPC);
+}
+
+static int h264_raw_write_nal_unit(H264RawContext *ctx,
+ uint8_t **data_pos,
+ size_t *data_size,
+ const H264RawNALUnit *nal)
+{
+ PutBitContext pbc;
+ uint8_t *raw_stream;
+ size_t bit_len;
+ size_t dst_bit_len;
+ int err;
+
+ raw_stream = av_malloc(1 << 24);
+ if (!raw_stream)
+ return AVERROR(ENOMEM);
+
+ init_put_bits(&pbc, raw_stream, 1 << 24);
+
+ switch (nal->type) {
+ case H264_NAL_SPS:
+ {
+ err = h264_raw_write_sps(ctx, &pbc, nal->sps);
+ if (err < 0)
+ goto fail;
+ h264_raw_replace_sps(ctx, nal->sps);
+ }
+ break;
+ case H264_NAL_PPS:
+ {
+ err = h264_raw_write_pps(ctx, &pbc, nal->pps);
+ if (err < 0)
+ goto fail;
+ h264_raw_replace_pps(ctx, nal->pps);
+ }
+ break;
+ case H264_NAL_SLICE:
+ case H264_NAL_IDR_SLICE:
+ {
+ BitstreamContext bc;
+ int bits_left, end, zeroes;
+
+ err = h264_raw_write_slice_header(ctx, &pbc, nal->slice.header);
+ if (err < 0)
+ goto fail;
+
+ bitstream_init(&bc, nal->slice.data,
+ nal->slice.data_length * 8);
+ bitstream_skip(&bc, nal->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));
+
+ bits_left = bitstream_bits_left(&bc);
+ end = bitstream_read(&bc, bits_left);
+
+ // rbsp_stop_one_bit must be present here.
+ av_assert0(end);
+ zeroes = ff_ctz(end);
+ if (bits_left > zeroes + 1)
+ put_bits(&pbc, bits_left - zeroes - 1,
+ end >> (zeroes + 1));
+ put_bits(&pbc, 1, 1);
+ while (put_bits_count(&pbc) % 8 != 0)
+ put_bits(&pbc, 1, 0);
+ }
+ break;
+ case H264_NAL_AUD:
+ {
+ err = h264_raw_write_aud(ctx, &pbc, nal->aud);
+ if (err < 0)
+ goto fail;
+ }
+ break;
+ case H264_NAL_SEI:
+ {
+ err = h264_raw_write_sei(ctx, &pbc, nal->sei);
+ if (err < 0)
+ goto fail;
+ }
+ break;
+ default:
+ av_log(ctx, AV_LOG_ERROR, "Discarding unsupported NAL unit %d.\n",
+ nal->type);
+ break;
+ }
+
+ av_assert0(put_bits_count(&pbc) % 8 == 0);
+ bit_len = put_bits_count(&pbc);
+ flush_put_bits(&pbc);
+
+ dst_bit_len = *data_size * 8;
+ err = h264_raw_write_emulation_prevention(*data_pos, &dst_bit_len,
+ raw_stream, bit_len);
+ if (err < 0) {
+ av_log(ctx, AV_LOG_ERROR, "Bitstream overflow?\n");
+ goto fail;
+ }
+
+ av_assert0(dst_bit_len % 8 == 0);
+ *data_size = dst_bit_len / 8;
+
+ err = 0;
+fail:
+ av_free(raw_stream);
+ return err;
+}
+
+static size_t h264_raw_write_guess_size(const H264RawAccessUnit *au)
+{
+ size_t size = 0;
+ int i;
+
+ for (i = 0; i < au->nb_nal_units; i++) {
+ switch (au->nal_units[i].type) {
+ case H264_NAL_SLICE:
+ case H264_NAL_IDR_SLICE:
+ size += 128 + au->nal_units[i].slice.data_length * 3 / 2;
+ break;
+ case H264_NAL_SPS:
+ case H264_NAL_PPS:
+ case H264_NAL_AUD:
+ case H264_NAL_SEI:
+ size += 1024;
+ break;
+ default:
+ size += au->nal_units[i].other.data_length * 3 / 2;
+ }
+ }
+
+ return size;
+}
+
+static int h264_raw_write_access_unit(H264RawContext *ctx,
+ uint8_t *data,
+ size_t *data_length,
+ const H264RawAccessUnit *au)
+{
+ uint8_t *pos;
+ size_t size;
+ int err, i;
+
+ pos = data;
+ for (i = 0; i < au->nb_nal_units; i++) {
+ size = data + *data_length - pos;
+
+ err = h264_raw_write_nal_unit(ctx, &pos, &size,
+ &au->nal_units[i]);
+ if (err < 0)
+ return err;
+
+ pos += size;
+ }
+
+ *data_length = pos - data;
+ return 0;
+}
+
+int ff_h264_raw_write_extradata(H264RawContext *ctx,
+ AVCodecParameters *par,
+ const H264RawAccessUnit *au)
+{
+ int err;
+ size_t size;
+
+ size = h264_raw_write_guess_size(au);
+
+ av_freep(&par->extradata);
+
+ par->extradata = av_malloc(size);
+ if (!par->extradata)
+ return AVERROR(ENOMEM);
+
+ err = h264_raw_write_access_unit(ctx, par->extradata, &size, au);
+ if (err < 0)
+ goto fail;
+
+ par->extradata_size = size;
+
+ err = av_reallocp(&par->extradata, size +
+ AV_INPUT_BUFFER_PADDING_SIZE);
+ if (err < 0)
+ goto fail;
+ memset(par->extradata + size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
+
+ return 0;
+fail:
+ return err;
+}
+
+int ff_h264_raw_write_packet(H264RawContext *ctx,
+ AVPacket *pkt,
+ const H264RawAccessUnit *au)
+{
+ int err;
+ size_t size;
+
+ size = h264_raw_write_guess_size(au);
+
+ err = av_new_packet(pkt, size);
+ if (err < 0)
+ return err;
+
+ err = h264_raw_write_access_unit(ctx, pkt->data, &size, au);
+ if (err < 0)
+ goto fail;
+
+ av_assert0(size <= pkt->size);
+ pkt->size = size;
+
+ return 0;
+
+fail:
+ return err;
+}
+
+static void h264_raw_nal_unit_sei_uninit(H264RawNALUnit *nal)
+{
+ int i;
+
+ for (i = 0; i < nal->sei->payload_count; i++) {
+ H264RawSEIPayload *payload = &nal->sei->payload[i];
+
+ switch (payload->payload_type) {
+ case SEI_TYPE_BUFFERING_PERIOD:
+ case SEI_TYPE_PIC_TIMING:
+ case SEI_TYPE_FILLER:
+ case SEI_TYPE_RECOVERY_POINT:
+ case SEI_TYPE_DISPLAY_ORIENTATION:
+ break;
+ case SEI_TYPE_USER_DATA_REGISTERED:
+ av_freep(&nal->sei->payload[i].user_data_registered.data);
+ break;
+ case SEI_TYPE_USER_DATA_UNREGISTERED:
+ av_freep(&nal->sei->payload[i].user_data_unregistered.data);
+ break;
+ default:
+ av_freep(&nal->sei->payload[i].other.data);
+ break;
+ }
+ }
+
+ av_freep(&nal->sei);
+}
+
+void ff_h264_raw_nal_unit_uninit(H264RawNALUnit *nal)
+{
+ switch (nal->type) {
+ case H264_NAL_SPS:
+ av_freep(&nal->sps);
+ break;
+ case H264_NAL_PPS:
+ av_freep(&nal->pps);
+ break;
+ case H264_NAL_SLICE:
+ case H264_NAL_IDR_SLICE:
+ av_freep(&nal->slice.header);
+ av_freep(&nal->slice.data);
+ break;
+ case H264_NAL_AUD:
+ av_freep(&nal->aud);
+ break;
+ case H264_NAL_SEI:
+ h264_raw_nal_unit_sei_uninit(nal);
+ break;
+ default:
+ av_freep(&nal->other.data);
+ }
+}
+
+void ff_h264_raw_access_unit_uninit(H264RawAccessUnit *au)
+{
+ int i;
+
+ for (i = 0; i < au->nb_nal_units; i++)
+ ff_h264_raw_nal_unit_uninit(&au->nal_units[i]);
+
+ av_free(au->nal_units);
+}
+
+int ff_h264_raw_init(H264RawContext *ctx, void *log_ctx)
+{
+ if (log_ctx)
+ memcpy(&ctx->log_class, log_ctx, sizeof(void*));
+ else
+ ctx->log_class = NULL;
+
+ ctx->trace_enable = 0;
+ ctx->trace_level = AV_LOG_TRACE;
+
+ ctx->fatal_errors = 1;
+
+ memset(ctx->sps, 0, sizeof(ctx->sps));
+ memset(ctx->pps, 0, sizeof(ctx->pps));
+
+ ctx->active_sps = NULL;
+ ctx->active_pps = NULL;
+
+ return 0;
+}
+
+void ff_h264_raw_uninit(H264RawContext *ctx)
+{
+ int i;
+
+ for (i = 0; i < FF_ARRAY_ELEMS(ctx->sps); i++)
+ av_freep(&ctx->sps[i]);
+ for (i = 0; i < FF_ARRAY_ELEMS(ctx->pps); i++)
+ av_freep(&ctx->pps[i]);
+}
diff --git a/libavcodec/h264_raw.h b/libavcodec/h264_raw.h
new file mode 100644
index 000000000..710ca7450
--- /dev/null
+++ b/libavcodec/h264_raw.h
@@ -0,0 +1,439 @@
+/*
+ * This file is part of Libav.
+ *
+ * Libav 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef AVCODEC_H264_RAW_H
+#define AVCODEC_H264_RAW_H
+
+#include "libavutil/log.h"
+
+
+typedef struct H264RawScalingList {
+ int8_t delta_scale[64];
+} H264RawScalingList;
+
+typedef struct H264RawHRD {
+ uint8_t cpb_cnt_minus1;
+ uint8_t bit_rate_scale;
+ uint8_t cpb_size_scale;
+
+#define MAX_CPB_CNT 32
+ uint32_t bit_rate_value_minus1[MAX_CPB_CNT];
+ uint32_t cpb_size_value_minus1[MAX_CPB_CNT];
+ uint8_t cbr_flag[MAX_CPB_CNT];
+
+ uint8_t initial_cpb_removal_delay_length_minus1;
+ uint8_t cpb_removal_delay_length_minus1;
+ uint8_t dpb_output_delay_length_minus1;
+ uint8_t time_offset_length;
+} H264RawHRD;
+
+typedef struct H264RawVUI {
+ uint8_t aspect_ratio_info_present_flag;
+ uint8_t aspect_ratio_idc;
+ uint16_t sar_width;
+ uint16_t sar_height;
+
+ uint8_t overscan_info_present_flag;
+ uint8_t overscan_appropriate_flag;
+
+ uint8_t video_signal_type_present_flag;
+ uint8_t video_format;
+ uint8_t video_full_range_flag;
+ uint8_t colour_description_present_flag;
+ uint8_t colour_primaries;
+ uint8_t transfer_characteristics;
+ uint8_t matrix_coefficients;
+
+ uint8_t chroma_loc_info_present_flag;
+ uint8_t chroma_sample_loc_type_top_field;
+ uint8_t chroma_sample_loc_type_bottom_field;
+
+ uint8_t timing_info_present_flag;
+ uint32_t num_units_in_tick;
+ uint32_t time_scale;
+ uint8_t fixed_frame_rate_flag;
+
+ uint8_t nal_hrd_parameters_present_flag;
+ H264RawHRD nal_hrd_parameters;
+ uint8_t vcl_hrd_parameters_present_flag;
+ H264RawHRD vcl_hrd_parameters;
+ uint8_t low_delay_hrd_flag;
+
+ uint8_t pic_struct_present_flag;
+
+ uint8_t bitstream_restriction_flag;
+ uint8_t motion_vectors_over_pic_boundaries_flag;
+ uint8_t max_bytes_per_pic_denom;
+ uint8_t max_bits_per_mb_denom;
+ uint8_t log2_max_mv_length_horizontal;
+ uint8_t log2_max_mv_length_vertical;
+ uint8_t max_num_reorder_frames;
+ uint8_t max_dec_frame_buffering;
+} H264RawVUI;
+
+typedef struct H264RawSPS {
+ uint8_t forbidden_zero_bit;
+ uint8_t nal_ref_idc;
+ uint8_t nal_unit_type;
+
+ uint8_t profile_idc;
+ uint8_t constraint_set0_flag;
+ uint8_t constraint_set1_flag;
+ uint8_t constraint_set2_flag;
+ uint8_t constraint_set3_flag;
+ uint8_t constraint_set4_flag;
+ uint8_t constraint_set5_flag;
+ uint8_t reserved_zero_2bits;
+ uint8_t level_idc;
+
+ uint8_t seq_parameter_set_id;
+
+ uint8_t chroma_format_idc;
+ uint8_t separate_colour_plane_flag;
+ uint8_t bit_depth_luma_minus8;
+ uint8_t bit_depth_chroma_minus8;
+ uint8_t qpprime_y_zero_transform_bypass_flag;
+
+ uint8_t seq_scaling_matrix_present_flag;
+ uint8_t seq_scaling_list_present_flag[12];
+ H264RawScalingList scaling_list_4x4[6];
+ H264RawScalingList scaling_list_8x8[6];
+
+ uint8_t log2_max_frame_num_minus4;
+ uint8_t pic_order_cnt_type;
+ uint8_t log2_max_pic_order_cnt_lsb_minus4;
+ uint8_t delta_pic_order_always_zero_flag;
+ int32_t offset_for_non_ref_pic;
+ int32_t offset_for_top_to_bottom_field;
+ uint8_t num_ref_frames_in_pic_order_cnt_cycle;
+ int32_t offset_for_ref_frame[256];
+
+ uint8_t max_num_ref_frames;
+ uint8_t gaps_in_frame_num_allowed_flag;
+
+ uint16_t pic_width_in_mbs_minus1;
+ uint16_t pic_height_in_map_units_minus1;
+
+ uint8_t frame_mbs_only_flag;
+ uint8_t mb_adaptive_frame_field_flag;
+ uint8_t direct_8x8_inference_flag;
+
+ uint8_t frame_cropping_flag;
+ uint16_t frame_crop_left_offset;
+ uint16_t frame_crop_right_offset;
+ uint16_t frame_crop_top_offset;
+ uint16_t frame_crop_bottom_offset;
+
+ uint8_t vui_parameters_present_flag;
+ H264RawVUI vui;
+} H264RawSPS;
+
+typedef struct H264RawPPS {
+ uint8_t forbidden_zero_bit;
+ uint8_t nal_ref_idc;
+ uint8_t nal_unit_type;
+
+ uint8_t pic_parameter_set_id;
+ uint8_t seq_parameter_set_id;
+
+ uint8_t entropy_coding_mode_flag;
+ uint8_t bottom_field_pic_order_in_frame_present_flag;
+
+ uint8_t num_slice_groups_minus1;
+ uint8_t slice_group_map_type;
+
+ uint8_t num_ref_idx_l0_default_active_minus1;
+ uint8_t num_ref_idx_l1_default_active_minus1;
+
+ uint8_t weighted_pred_flag;
+ uint8_t weighted_bipred_idc;
+
+ int8_t pic_init_qp_minus26;
+ int8_t pic_init_qs_minus26;
+ int8_t chroma_qp_index_offset;
+
+ uint8_t deblocking_filter_control_present_flag;
+ uint8_t constrained_intra_pred_flag;
+ uint8_t redundant_pic_cnt_present_flag;
+ uint8_t transform_8x8_mode_flag;
+
+ uint8_t pic_scaling_matrix_present_flag;
+ uint8_t pic_scaling_list_present_flag[12];
+ H264RawScalingList scaling_list_4x4[6];
+ H264RawScalingList scaling_list_8x8[6];
+
+ int8_t second_chroma_qp_index_offset;
+} H264RawPPS;
+
+typedef struct H264RawAUD {
+ uint8_t forbidden_zero_bit;
+ uint8_t nal_ref_idc;
+ uint8_t nal_unit_type;
+
+ uint8_t primary_pic_type;
+} H264RawAUD;
+
+typedef struct H264RawSEIBufferingPeriod {
+ uint8_t seq_parameter_set_id;
+ struct {
+ uint32_t initial_cpb_removal_delay[32];
+ uint32_t initial_cpb_removal_delay_offset[32];
+ } nal, vcl;
+} H264RawSEIBufferingPeriod;
+
+typedef struct H264RawSEIPicTimestamp {
+ uint8_t ct_type;
+ uint8_t nuit_field_based_flag;
+ uint8_t counting_type;
+ uint8_t full_timestamp_flag;
+ uint8_t discontinuity_flag;
+ uint8_t cnt_dropped_flag;
+ uint8_t n_frames;
+ uint8_t seconds_flag;
+ uint8_t seconds_value;
+ uint8_t minutes_flag;
+ uint8_t minutes_value;
+ uint8_t hours_flag;
+ uint8_t hours_value;
+ uint32_t time_offset;
+} H264RawSEIPicTimestamp;
+
+typedef struct H264RawSEIPicTiming {
+ uint32_t cpb_removal_delay;
+ uint32_t dpb_output_delay;
+ uint8_t pic_struct;
+ uint8_t clock_timestamp_flag[3];
+ H264RawSEIPicTimestamp timestamp[3];
+} H264RawSEIPicTiming;
+
+typedef struct H264RawSEIUserDataRegistered {
+ uint8_t itu_t_t35_country_code;
+ uint8_t itu_t_t35_country_code_extension_byte;
+ uint8_t *data;
+ size_t data_length;
+} H264RawSEIUserDataRegistered;
+
+typedef struct H264RawSEIUserDataUnregistered {
+ uint8_t uuid_iso_iec_11578[16];
+ uint8_t *data;
+ size_t data_length;
+} H264RawSEIUserDataUnregistered;
+
+typedef struct H264RawSEIRecoveryPoint {
+ uint16_t recovery_frame_cnt;
+ uint8_t exact_match_flag;
+ uint8_t broken_link_flag;
+ uint8_t changing_slice_group_idc;
+} H264RawSEIRecoveryPoint;
+
+typedef struct H264RawSEIDisplayOrientation {
+ uint8_t display_orientation_cancel_flag;
+ uint8_t hor_flip;
+ uint8_t ver_flip;
+ uint16_t anticlockwise_rotation;
+ uint16_t display_orientation_repetition_period;
+ uint8_t display_orientation_extension_flag;
+} H264RawSEIDisplayOrientation;
+
+typedef struct H264RawSEIPayload {
+ uint32_t payload_type;
+ uint32_t payload_size;
+ union {
+ H264RawSEIBufferingPeriod buffering_period;
+ H264RawSEIPicTiming pic_timing;
+ // H264RawSEIFiller filler -> no fields.
+ H264RawSEIUserDataRegistered user_data_registered;
+ H264RawSEIUserDataUnregistered user_data_unregistered;
+ H264RawSEIRecoveryPoint recovery_point;
+ H264RawSEIDisplayOrientation display_orientation;
+ struct {
+ uint8_t *data;
+ size_t data_length;
+ } other;
+ };
+} H264RawSEIPayload;
+
+typedef struct H264RawSEI {
+ uint8_t forbidden_zero_bit;
+ uint8_t nal_ref_idc;
+ uint8_t nal_unit_type;
+
+#define MAX_SEI_PAYLOADS 100
+ H264RawSEIPayload payload[MAX_SEI_PAYLOADS];
+ uint8_t payload_count;
+} H264RawSEI;
+
+typedef struct H264RawSliceHeader {
+ uint8_t forbidden_zero_bit;
+ uint8_t nal_ref_idc;
+ uint8_t nal_unit_type;
+
+ uint32_t first_mb_in_slice;
+ uint8_t slice_type;
+
+ uint8_t pic_parameter_set_id;
+
+ uint8_t colour_plane_id;
+
+ uint16_t frame_num;
+ uint8_t field_pic_flag;
+ uint8_t bottom_field_flag;
+
+ uint16_t idr_pic_id;
+
+ uint16_t pic_order_cnt_lsb;
+ int32_t delta_pic_order_cnt_bottom;
+ int32_t delta_pic_order_cnt[2];
+
+ uint8_t redundant_pic_cnt;
+ uint8_t direct_spatial_mv_pred_flag;
+
+ uint8_t num_ref_idx_active_override_flag;
+ uint8_t num_ref_idx_l0_active_minus1;
+ uint8_t num_ref_idx_l1_active_minus1;
+
+#define MAX_RPLM 100
+ uint8_t ref_pic_list_modification_flag_l0;
+ uint8_t ref_pic_list_modification_flag_l1;
+ struct {
+ uint8_t modification_of_pic_nums_idc;
+ int32_t abs_diff_pic_num_minus1;
+ uint8_t long_term_pic_num;
+ } rplm_l0[MAX_RPLM], rplm_l1[MAX_RPLM];
+
+ uint8_t luma_log2_weight_denom;
+ uint8_t chroma_log2_weight_denom;
+
+ struct {
+ uint8_t luma_weight_l0_flag;
+ int8_t luma_weight_l0;
+ int8_t luma_offset_l0;
+ uint8_t chroma_weight_l0_flag;
+ int8_t chroma_weight_l0[2];
+ int8_t chroma_offset_l0[2];
+ } pwt_l0[32];
+
+ struct {
+ uint8_t luma_weight_l1_flag;
+ int8_t luma_weight_l1;
+ int8_t luma_offset_l1;
+ uint8_t chroma_weight_l1_flag;
+ int8_t chroma_weight_l1[2];
+ int8_t chroma_offset_l1[2];
+ } pwt_l1[32];
+
+ uint8_t no_output_of_prior_pics_flag;
+ uint8_t long_term_reference_flag;
+
+#define MAX_MMCO 100
+ uint8_t adaptive_ref_pic_marking_mode_flag;
+ struct {
+ uint8_t memory_management_control_operation;
+ int32_t difference_of_pic_nums_minus1;
+ uint8_t long_term_pic_num;
+ uint8_t long_term_frame_idx;
+ uint8_t max_long_term_frame_idx_plus1;
+ } mmco[MAX_MMCO];
+
+ uint8_t cabac_init_idc;
+
+ int8_t slice_qp_delta;
+
+ uint8_t sp_for_switch_flag;
+ int8_t slice_qs_delta;
+
+ uint8_t disable_deblocking_filter_idc;
+ int8_t slice_alpha_c0_offset_div2;
+ int8_t slice_beta_offset_div2;
+} H264RawSliceHeader;
+
+
+typedef struct H264RawContext {
+ AVClass *log_class;
+
+ int avcc;
+ int nal_length_size;
+
+ int trace_enable;
+ int trace_level;
+
+ void (*trace_callback)(void *context, int new_block,
+ const char *format, ...);
+ void *trace_callback_context;
+
+ int fatal_errors;
+
+ H264RawSPS *sps[32];
+ H264RawPPS *pps[256];
+
+ const H264RawSPS *active_sps;
+ const H264RawPPS *active_pps;
+} H264RawContext;
+
+typedef struct H264RawNALUnit {
+ int type;
+ int size;
+ union {
+ H264RawSPS *sps;
+ H264RawPPS *pps;
+ struct {
+ H264RawSliceHeader *header;
+ uint8_t *data;
+ size_t data_length;
+ int data_bit_start;
+ } slice;
+ H264RawAUD *aud;
+ H264RawSEI *sei;
+ struct {
+ uint8_t *data;
+ size_t data_length;
+ } other;
+ };
+} H264RawNALUnit;
+
+typedef struct H264RawAccessUnit {
+ int nb_nal_units;
+ H264RawNALUnit *nal_units;
+} H264RawAccessUnit;
+
+
+int ff_h264_raw_read_extradata(H264RawContext *ctx,
+ H264RawAccessUnit *au,
+ const AVCodecParameters *par);
+
+int ff_h264_raw_read_packet(H264RawContext *ctx,
+ H264RawAccessUnit *au,
+ const AVPacket *avpkt);
+
+int ff_h264_raw_write_extradata(H264RawContext *ctx,
+ AVCodecParameters *par,
+ const H264RawAccessUnit *au);
+
+int ff_h264_raw_write_packet(H264RawContext *ctx,
+ AVPacket *pkt,
+ const H264RawAccessUnit *au);
+
+void ff_h264_raw_nal_unit_uninit(H264RawNALUnit *nal);
+void ff_h264_raw_access_unit_uninit(H264RawAccessUnit *au);
+
+int ff_h264_raw_init(H264RawContext *ctx, void *log_ctx);
+
+void ff_h264_raw_uninit(H264RawContext *ctx);
+
+
+#endif /* AVCODEC_H264_RAW_H */
diff --git a/libavcodec/h264_raw_syntax.c b/libavcodec/h264_raw_syntax.c
new file mode 100644
index 000000000..97301b794
--- /dev/null
+++ b/libavcodec/h264_raw_syntax.c
@@ -0,0 +1,1476 @@
+/*
+ * This file is part of Libav.
+ *
+ * Libav 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,
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#if defined(READ)
+
+#define READWRITE read
+#define RWContext BitstreamContext
+
+
+static int h264_raw_read_u(H264RawContext *ctx, BitstreamContext *bc,
+ int width, const char *name, uint32_t *write_to,
+ uint32_t range_min, uint32_t range_max)
+{
+ uint32_t value;
+ int position;
+
+ av_assert0(width <= 32);
+
+ if (ctx->trace_enable)
+ position = bitstream_tell(bc);
+
+ value = bitstream_read(bc, width);
+
+ if (ctx->trace_enable) {
+ char bits[33];
+ int i;
+ for (i = 0; i < width; i++)
+ bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
+ bits[i] = 0;
+
+ h264_raw_trace(ctx, position, name, bits, value);
+ }
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRIu32", but "
+ "must be in [%"PRIu32",%"PRIu32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+
+ *write_to = value;
+ return 0;
+}
+
+static int h264_raw_read_ue(H264RawContext *ctx, BitstreamContext *bc,
+ const char *name, uint32_t *write_to,
+ uint32_t range_min, uint32_t range_max)
+{
+ uint32_t value;
+ int position;
+
+ if (ctx->trace_enable) {
+ char bits[65];
+ unsigned int k;
+ int i, j;
+
+ position = bitstream_tell(bc);
+
+ for (i = 0; i < 32; i++) {
+ k = bitstream_read_bit(bc);
+ bits[i] = k ? '1' : '0';
+ if (k)
+ break;
+ }
+ if (i >= 32) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid ue-golomb code while "
+ "reading %s: more than 32 zeroes found.\n", name);
+ return AVERROR_INVALIDDATA;
+ }
+ value = 1;
+ for (j = 0; j < i; j++) {
+ k = bitstream_read_bit(bc);
+ bits[i + j + 1] = k ? '1' : '0';
+ value = value << 1 | k;
+ }
+ bits[i + j + 1] = 0;
+ --value;
+
+ h264_raw_trace(ctx, position, name, bits, value);
+ } else {
+ value = get_ue_golomb_long(bc);
+ }
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRIu32", but "
+ "must be in [%"PRIu32",%"PRIu32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+
+ *write_to = value;
+ return 0;
+}
+
+static int h264_raw_read_se(H264RawContext *ctx, BitstreamContext *bc,
+ const char *name, int32_t *write_to,
+ int32_t range_min, int32_t range_max)
+{
+ int32_t value;
+ int position;
+
+ if (ctx->trace_enable) {
+ char bits[65];
+ uint32_t v;
+ unsigned int k;
+ int i, j;
+
+ position = bitstream_tell(bc);
+
+ for (i = 0; i < 32; i++) {
+ k = bitstream_read_bit(bc);
+ bits[i] = k ? '1' : '0';
+ if (k)
+ break;
+ }
+ if (i >= 32) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid se-golomb code while "
+ "reading %s: more than 32 zeroes found.\n", name);
+ return AVERROR_INVALIDDATA;
+ }
+ v = 1;
+ for (j = 0; j < i; j++) {
+ k = bitstream_read_bit(bc);
+ bits[i + j + 1] = k ? '1' : '0';
+ v = v << 1 | k;
+ }
+ bits[i + j + 1] = 0;
+ if (v & 1)
+ value = -(int32_t)(v / 2);
+ else
+ value = v / 2;
+
+ h264_raw_trace(ctx, position, name, bits, value);
+ } else {
+ value = get_se_golomb_long(bc);
+ }
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRId32", but "
+ "must be in [%"PRId32",%"PRId32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+
+ *write_to = value;
+ return 0;
+}
+
+
+#define xu(width, name, var, range_min, range_max) do { \
+ uint32_t value = range_min; \
+ CHECK(h264_raw_read_u(ctx, rw, width, #name, \
+ &value, range_min, range_max)); \
+ var = value; \
+ } while (0)
+#define xue(name, var, range_min, range_max) do { \
+ uint32_t value = range_min; \
+ CHECK(h264_raw_read_ue(ctx, rw, #name, \
+ &value, range_min, range_max)); \
+ var = value; \
+ } while (0)
+#define xse(name, var, range_min, range_max) do { \
+ int32_t value = range_min; \
+ CHECK(h264_raw_read_se(ctx, rw, #name, \
+ &value, range_min, range_max)); \
+ var = value; \
+ } while (0)
+
+
+#define u(width, name, range_min, range_max) \
+ xu(width, name, current->name, range_min, range_max)
+#define flag(name) u(1, name, 0, 1)
+#define ue(name, range_min, range_max) \
+ xue(name, current->name, range_min, range_max)
+#define se(name, range_min, range_max) \
+ xse(name, current->name, range_min, range_max)
+
+#define infer(name, value) do { \
+ current->name = value; \
+ } while (0)
+
+
+static int h264_raw_read_more_rbsp_data(BitstreamContext *bc)
+{
+ int bits_left = bitstream_bits_left(bc);
+ if (bits_left > 8)
+ return 1;
+ if (bitstream_peek(bc, bits_left) == 1 << (bits_left - 1))
+ return 0;
+ return 1;
+}
+
+#define byte_alignment(rw) (bitstream_tell(rw) % 8)
+
+#define allocate(name, size) do { \
+ name = av_mallocz(size); \
+ if (!name) \
+ return AVERROR(ENOMEM); \
+ } while (0)
+
+
+#elif defined(WRITE)
+
+#define READWRITE write
+#define RWContext PutBitContext
+
+
+static int h264_raw_write_u(H264RawContext *ctx, PutBitContext *pbc,
+ int width, const char *name, uint32_t value,
+ uint32_t range_min, uint32_t range_max)
+{
+ av_assert0(width <= 32);
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRIu32", but "
+ "must be in [%"PRIu32",%"PRIu32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (ctx->trace_enable) {
+ char bits[33];
+ int i;
+ for (i = 0; i < width; i++)
+ bits[i] = value >> (width - i - 1) & 1 ? '1' : '0';
+ bits[i] = 0;
+
+ h264_raw_trace(ctx, put_bits_count(pbc), name, bits, value);
+ }
+
+ if (width < 32)
+ put_bits(pbc, width, value);
+ else
+ put_bits32(pbc, value);
+
+ return 0;
+}
+
+static int h264_raw_write_ue(H264RawContext *ctx, PutBitContext *pbc,
+ const char *name, uint32_t value,
+ uint32_t range_min, uint32_t range_max)
+{
+ int len;
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRIu32", but "
+ "must be in [%"PRIu32",%"PRIu32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+ av_assert0(value != UINT32_MAX);
+
+ len = av_log2(value + 1);
+
+ if (ctx->trace_enable) {
+ char bits[65];
+ int i;
+
+ for (i = 0; i < len; i++)
+ bits[i] = '0';
+ bits[len] = '1';
+ for (i = 0; i < len; i++)
+ bits[len + i + 1] = (value + 1) >> (len - i - 1) & 1 ? '1' : '0';
+ bits[len + len + 1] = 0;
+
+ h264_raw_trace(ctx, put_bits_count(pbc), name, bits, value);
+ }
+
+ put_bits(pbc, len, 0);
+ if (len + 1 < 32)
+ put_bits(pbc, len + 1, value + 1);
+ else
+ put_bits32(pbc, value + 1);
+
+ return 0;
+}
+
+static int h264_raw_write_se(H264RawContext *ctx, PutBitContext *pbc,
+ const char *name, int32_t value,
+ int32_t range_min, int32_t range_max)
+{
+ int len;
+ uint32_t uvalue;
+
+ if (value < range_min || value > range_max) {
+ av_log(ctx, AV_LOG_ERROR, "%s out of range: %"PRId32", but "
+ "must be in [%"PRId32",%"PRId32"].\n",
+ name, value, range_min, range_max);
+ return AVERROR_INVALIDDATA;
+ }
+ av_assert0(value != INT32_MIN);
+
+ if (value == 0)
+ uvalue = 0;
+ else if (value > 0)
+ uvalue = 2 * (uint32_t)value - 1;
+ else
+ uvalue = 2 * (uint32_t)-value;
+
+ len = av_log2(uvalue + 1);
+
+ if (ctx->trace_enable) {
+ char bits[65];
+ int i;
+
+ for (i = 0; i < len; i++)
+ bits[i] = '0';
+ bits[len] = '1';
+ for (i = 0; i < len; i++)
+ bits[len + i + 1] = (uvalue + 1) >> (len - i - 1) & 1 ? '1' : '0';
+ bits[len + len + 1] = 0;
+
+ h264_raw_trace(ctx, put_bits_count(pbc), name, bits, value);
+ }
+
+ put_bits(pbc, len, 0);
+ if (len + 1 < 32)
+ put_bits(pbc, len + 1, uvalue + 1);
+ else
+ put_bits32(pbc, uvalue + 1);
+
+ return 0;
+}
+
+
+#define xu(width, name, var, range_min, range_max) do { \
+ uint32_t value = var; \
+ CHECK(h264_raw_write_u(ctx, rw, width, #name, \
+ value, range_min, range_max)); \
+ } while (0)
+#define xue(name, var, range_min, range_max) do { \
+ uint32_t value = var; \
+ CHECK(h264_raw_write_ue(ctx, rw, #name, \
+ value, range_min, range_max)); \
+ } while (0)
+#define xse(name, var, range_min, range_max) do { \
+ int32_t value = var; \
+ CHECK(h264_raw_write_se(ctx, rw, #name, \
+ value, range_min, range_max)); \
+ } while (0)
+
+
+#define u(width, name, range_min, range_max) \
+ xu(width, name, current->name, range_min, range_max)
+#define flag(name) u(1, name, 0, 1)
+#define ue(name, range_min, range_max) \
+ xue(name, current->name, range_min, range_max)
+#define se(name, range_min, range_max) \
+ xse(name, current->name, range_min, range_max)
+
+#define infer(name, value) do { \
+ if (current->name != (value)) { \
+ av_log(ctx, AV_LOG_ERROR, "%s has incorrect value: " \
+ "%"PRId64", but must be %"PRId64".\n", \
+ #name, (int64_t)current->name, (int64_t)(value)); \
+ if (ctx->fatal_errors) \
+ return AVERROR_INVALIDDATA; \
+ } \
+ } while (0)
+
+
+#define byte_alignment(rw) (put_bits_count(rw) % 8)
+
+#define allocate(name, size) do { \
+ if (!name) { \
+ av_log(ctx, AV_LOG_ERROR, "%s must be set for writing.\n", \
+ #name); \
+ return AVERROR_INVALIDDATA; \
+ } \
+ } while (0)
+
+
+#else
+#error "This file is being used incorrectly."
+#endif
+
+
+#define HEADER(name) do { \
+ if (ctx->trace_enable) \
+ h264_raw_trace_header(ctx, name); \
+ } while (0)
+
+#define CHECK(call) do { \
+ err = (call); \
+ if (err < 0 && ctx->fatal_errors) \
+ return err; \
+ } while (0)
+
+#define FUNC3(rw, name) h264_raw_ ## rw ## _ ## name
+#define FUNC2(rw, name) FUNC3(rw, name)
+#define FUNC(name) FUNC2(READWRITE, name)
+
+
+static int FUNC(rbsp_trailing_bits)(H264RawContext *ctx, RWContext *rw)
+{
+ int err;
+ int one = 1, zero = 0;
+ xu(1, rbsp_stop_one_bit, one, 1, 1);
+ while (byte_alignment(rw) != 0)
+ xu(1, rbsp_alignment_zero_bit, zero, 0, 0);
+
+ return 0;
+}
+
+static int FUNC(scaling_list)(H264RawContext *ctx, RWContext *rw,
+ H264RawScalingList *current,
+ int size_of_scaling_list)
+{
+ int err, i, scale;
+
+ scale = 8;
+ for (i = 0; i < size_of_scaling_list; i++) {
+ xse(delta_scale, current->delta_scale[i], -128, +127);
+ scale = (scale + current->delta_scale[i] + 256) % 256;
+ if (scale == 0)
+ break;
+ }
+
+ return 0;
+}
+
+static int FUNC(hrd_parameters)(H264RawContext *ctx, RWContext *rw,
+ H264RawHRD *current)
+{
+ int err, i;
+
+ ue(cpb_cnt_minus1, 0, 31);
+ u(4, bit_rate_scale, 0, 15);
+ u(4, cpb_size_scale, 0, 15);
+
+ for (i = 0; i <= current->cpb_cnt_minus1; i++) {
+ ue(bit_rate_value_minus1[i], 0, UINT32_MAX - 1);
+ ue(cpb_size_value_minus1[i], 0, UINT32_MAX - 1);
+ flag(cbr_flag[i]);
+ }
+
+ u(5, initial_cpb_removal_delay_length_minus1, 0, 31);
+ u(5, cpb_removal_delay_length_minus1, 0, 31);
+ u(5, dpb_output_delay_length_minus1, 0, 31);
+ u(5, time_offset_length, 0, 31);
+
+ return 0;
+}
+
+static int FUNC(vui_parameters)(H264RawContext *ctx, RWContext *rw,
+ H264RawVUI *current, H264RawSPS *sps)
+{
+ int err;
+
+ flag(aspect_ratio_info_present_flag);
+ if (current->aspect_ratio_info_present_flag) {
+ u(8, aspect_ratio_idc, 0, 255);
+ if (current->aspect_ratio_idc == 255) {
+ u(16, sar_width, 0, 65535);
+ u(16, sar_height, 0, 65535);
+ }
+ } else {
+ infer(aspect_ratio_idc, 0);
+ }
+
+ flag(overscan_info_present_flag);
+ if (current->overscan_info_present_flag)
+ flag(overscan_appropriate_flag);
+
+ flag(video_signal_type_present_flag);
+ if (current->video_signal_type_present_flag) {
+ u(3, video_format, 0, 7);
+ flag(video_full_range_flag);
+ flag(colour_description_present_flag);
+ if (current->colour_description_present_flag) {
+ u(8, colour_primaries, 0, 255);
+ u(8, transfer_characteristics, 0, 255);
+ u(8, matrix_coefficients, 0, 255);
+ }
+ } else {
+ infer(video_format, 5);
+ infer(video_full_range_flag, 0);
+ infer(colour_primaries, 2);
+ infer(transfer_characteristics, 2);
+ infer(matrix_coefficients, 2);
+ }
+
+ flag(chroma_loc_info_present_flag);
+ if (current->chroma_loc_info_present_flag) {
+ ue(chroma_sample_loc_type_top_field, 0, 5);
+ ue(chroma_sample_loc_type_bottom_field, 0, 5);
+ } else {
+ infer(chroma_sample_loc_type_top_field, 0);
+ infer(chroma_sample_loc_type_bottom_field, 0);
+ }
+
+ flag(timing_info_present_flag);
+ if (current->timing_info_present_flag) {
+ u(32, num_units_in_tick, 1, UINT32_MAX);
+ u(32, time_scale, 1, UINT32_MAX);
+ flag(fixed_frame_rate_flag);
+ } else {
+ infer(fixed_frame_rate_flag, 0);
+ }
+
+ flag(nal_hrd_parameters_present_flag);
+ if (current->nal_hrd_parameters_present_flag) {
+ CHECK(FUNC(hrd_parameters)(ctx, rw, ¤t->nal_hrd_parameters));
+ }
+
+ flag(vcl_hrd_parameters_present_flag);
+ if (current->vcl_hrd_parameters_present_flag) {
+ CHECK(FUNC(hrd_parameters)(ctx, rw, ¤t->vcl_hrd_parameters));
+ }
+
+ if (current->nal_hrd_parameters_present_flag ||
+ current->vcl_hrd_parameters_present_flag)
+ flag(low_delay_hrd_flag);
+ else
+ infer(low_delay_hrd_flag, 1 - current->fixed_frame_rate_flag);
+
+ flag(pic_struct_present_flag);
+
+ flag(bitstream_restriction_flag);
+ if (current->bitstream_restriction_flag) {
+ flag(motion_vectors_over_pic_boundaries_flag);
+ ue(max_bytes_per_pic_denom, 0, 16);
+ ue(max_bits_per_mb_denom, 0, 16);
+ ue(log2_max_mv_length_horizontal, 0, 16);
+ ue(log2_max_mv_length_vertical, 0, 16);
+ ue(max_num_reorder_frames, 0, 16);
+ ue(max_dec_frame_buffering, 0, 16);
+ } else {
+ infer(motion_vectors_over_pic_boundaries_flag, 1);
+ infer(max_bytes_per_pic_denom, 2);
+ infer(max_bits_per_mb_denom, 1);
+ infer(log2_max_mv_length_horizontal, 16);
+ infer(log2_max_mv_length_vertical, 16);
+
+ if ((sps->profile_idc == 44 || sps->profile_idc == 86 ||
+ sps->profile_idc == 110 || sps->profile_idc == 110 ||
+ sps->profile_idc == 122 || sps->profile_idc == 244) &&
+ sps->constraint_set3_flag) {
+ infer(max_num_reorder_frames, 0);
+ infer(max_dec_frame_buffering, 0);
+ } else {
+ infer(max_num_reorder_frames, 16);
+ infer(max_dec_frame_buffering, 16);
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(sps)(H264RawContext *ctx, RWContext *rw,
+ H264RawSPS *current)
+{
+ int err, i;
+
+ HEADER("Sequence Parameter Set");
+
+ u(1, forbidden_zero_bit, 0, 0);
+ u(2, nal_ref_idc, 0, 3);
+ u(5, nal_unit_type, 0, 31);
+
+ u(8, profile_idc, 0, 255);
+
+ flag(constraint_set0_flag);
+ flag(constraint_set1_flag);
+ flag(constraint_set2_flag);
+ flag(constraint_set3_flag);
+ flag(constraint_set4_flag);
+ flag(constraint_set5_flag);
+
+ u(2, reserved_zero_2bits, 0, 0);
+
+ u(8, level_idc, 0, 255);
+
+ ue(seq_parameter_set_id, 0, 31);
+
+ if (current->profile_idc == 100 || current->profile_idc == 110 ||
+ current->profile_idc == 122 || current->profile_idc == 244 ||
+ current->profile_idc == 44 || current->profile_idc == 83 ||
+ current->profile_idc == 86 || current->profile_idc == 118 ||
+ current->profile_idc == 128 || current->profile_idc == 138) {
+ ue(chroma_format_idc, 0, 3);
+
+ if (current->chroma_format_idc == 3)
+ flag(separate_colour_plane_flag);
+ else
+ infer(separate_colour_plane_flag, 0);
+
+ ue(bit_depth_luma_minus8, 0, 6);
+ ue(bit_depth_chroma_minus8, 0, 6);
+
+ flag(qpprime_y_zero_transform_bypass_flag);
+
+ flag(seq_scaling_matrix_present_flag);
+ if (current->seq_scaling_matrix_present_flag) {
+ for (i = 0; i < ((current->chroma_format_idc != 3) ? 8 : 12); i++)
{
+ flag(seq_scaling_list_present_flag[i]);
+ if (current->seq_scaling_list_present_flag[i]) {
+ if (i < 6)
+ CHECK(FUNC(scaling_list)(ctx, rw,
+ ¤t->scaling_list_4x4[i],
+ 16));
+ else
+ CHECK(FUNC(scaling_list)(ctx, rw,
+ ¤t->scaling_list_8x8[i
- 6],
+ 64));
+ }
+ }
+ }
+ } else {
+ infer(chroma_format_idc, current->profile_idc == 183 ? 0 : 1);
+
+ infer(separate_colour_plane_flag, 0);
+ infer(bit_depth_luma_minus8, 0);
+ infer(bit_depth_chroma_minus8, 0);
+ }
+
+ ue(log2_max_frame_num_minus4, 0, 12);
+ ue(pic_order_cnt_type, 0, 2);
+
+ if (current->pic_order_cnt_type == 0) {
+ ue(log2_max_pic_order_cnt_lsb_minus4, 0, 12);
+ } else if (current->pic_order_cnt_type == 1) {
+ flag(delta_pic_order_always_zero_flag);
+ se(offset_for_non_ref_pic, INT32_MIN + 1, INT32_MAX);
+ se(offset_for_top_to_bottom_field, INT32_MIN + 1, INT32_MAX);
+ ue(num_ref_frames_in_pic_order_cnt_cycle, 0, 255);
+
+ for (i = 0; i < current->num_ref_frames_in_pic_order_cnt_cycle; i++)
+ se(offset_for_ref_frame[i], INT32_MIN + 1, INT32_MAX);
+ }
+
+ ue(max_num_ref_frames, 0, 16);
+ flag(gaps_in_frame_num_allowed_flag);
+
+ ue(pic_width_in_mbs_minus1, 0, 1024);
+ ue(pic_height_in_map_units_minus1, 0, 1024);
+
+ flag(frame_mbs_only_flag);
+ if (!current->frame_mbs_only_flag)
+ flag(mb_adaptive_frame_field_flag);
+
+ flag(direct_8x8_inference_flag);
+
+ flag(frame_cropping_flag);
+ if (current->frame_cropping_flag) {
+ ue(frame_crop_left_offset, 0, 16384);
+ ue(frame_crop_right_offset, 0, 16384);
+ ue(frame_crop_top_offset, 0, 16384);
+ ue(frame_crop_bottom_offset, 0, 16384);
+ }
+
+ flag(vui_parameters_present_flag);
+ if (current->vui_parameters_present_flag)
+ CHECK(FUNC(vui_parameters)(ctx, rw, ¤t->vui, current));
+
+ CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+ return 0;
+}
+
+static int FUNC(pps)(H264RawContext *ctx, RWContext *rw,
+ H264RawPPS *current)
+{
+ const H264RawSPS *sps;
+ int err, i;
+
+ HEADER("Picture Parameter Set");
+
+ u(1, forbidden_zero_bit, 0, 0);
+ u(2, nal_ref_idc, 0, 3);
+ u(5, nal_unit_type, 0, 31);
+
+ ue(pic_parameter_set_id, 0, 255);
+ ue(seq_parameter_set_id, 0, 31);
+
+ sps = ctx->sps[current->seq_parameter_set_id];
+ if (!sps) {
+ av_log(ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
+ current->seq_parameter_set_id);
+ return AVERROR_INVALIDDATA;
+ }
+
+ flag(entropy_coding_mode_flag);
+ flag(bottom_field_pic_order_in_frame_present_flag);
+
+ ue(num_slice_groups_minus1, 0, 7);
+ if (current->num_slice_groups_minus1 > 0) {
+ ue(slice_group_map_type, 0, 6);
+ av_log(ctx, AV_LOG_ERROR, "FMO not supported.\n");
+ return AVERROR_PATCHWELCOME;
+ }
+
+ ue(num_ref_idx_l0_default_active_minus1, 0, 31);
+ ue(num_ref_idx_l1_default_active_minus1, 0, 31);
+
+ flag(weighted_pred_flag);
+ u(2, weighted_bipred_idc, 0, 2);
+
+ se(pic_init_qp_minus26, -26 - 6 * sps->bit_depth_luma_minus8, +25);
+ se(pic_init_qs_minus26, -26, +25);
+ se(chroma_qp_index_offset, -12, +12);
+
+ flag(deblocking_filter_control_present_flag);
+ flag(constrained_intra_pred_flag);
+ flag(redundant_pic_cnt_present_flag);
+
+#ifdef READ
+ if (h264_raw_read_more_rbsp_data(rw))
+#else
+ if (1)
+#endif
+ {
+ flag(transform_8x8_mode_flag);
+
+ flag(pic_scaling_matrix_present_flag);
+ if (current->pic_scaling_matrix_present_flag) {
+ for (i = 0; i < 6 + (((sps->chroma_format_idc != 3) ? 2 : 6) *
+ current->transform_8x8_mode_flag); i++) {
+ flag(pic_scaling_list_present_flag[i]);
+ if (current->pic_scaling_list_present_flag[i]) {
+ if (i < 6)
+ CHECK(FUNC(scaling_list)(ctx, rw,
+ ¤t->scaling_list_4x4[i],
+ 16));
+ else
+ CHECK(FUNC(scaling_list)(ctx, rw,
+ ¤t->scaling_list_8x8[i
- 6],
+ 64));
+ }
+ }
+ }
+
+ se(second_chroma_qp_index_offset, -12, +12);
+ } else {
+ infer(transform_8x8_mode_flag, 0);
+ infer(second_chroma_qp_index_offset, current->chroma_qp_index_offset);
+ }
+
+ CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+ return 0;
+}
+
+static int FUNC(sei_buffering_period)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIBufferingPeriod *current)
+{
+ const H264RawSPS *sps;
+ int err, i, length;
+
+ ue(seq_parameter_set_id, 0, 31);
+
+ sps = ctx->sps[current->seq_parameter_set_id];
+ if (!sps) {
+ av_log(ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
+ current->seq_parameter_set_id);
+ return AVERROR_INVALIDDATA;
+ }
+ ctx->active_sps = sps;
+
+ if (sps->vui.nal_hrd_parameters_present_flag) {
+ for (i = 0; i <= sps->vui.nal_hrd_parameters.cpb_cnt_minus1; i++) {
+ length =
sps->vui.nal_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
+ xu(length, initial_cpb_removal_delay[SchedSelIdx],
+ current->nal.initial_cpb_removal_delay[i],
+ 0, (1 << (uint64_t)length) - 1);
+ xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
+ current->nal.initial_cpb_removal_delay_offset[i],
+ 0, (1 << (uint64_t)length) - 1);
+ }
+ }
+
+ if (sps->vui.vcl_hrd_parameters_present_flag) {
+ for (i = 0; i <= sps->vui.vcl_hrd_parameters.cpb_cnt_minus1; i++) {
+ length =
sps->vui.vcl_hrd_parameters.initial_cpb_removal_delay_length_minus1 + 1;
+ xu(length, initial_cpb_removal_delay[SchedSelIdx],
+ current->vcl.initial_cpb_removal_delay[i],
+ 0, (1 << (uint64_t)length) - 1);
+ xu(length, initial_cpb_removal_delay_offset[SchedSelIdx],
+ current->vcl.initial_cpb_removal_delay_offset[i],
+ 0, (1 << (uint64_t)length) - 1);
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(sei_pic_timestamp)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIPicTimestamp *current)
+{
+ const H264RawSPS *sps;
+ uint8_t time_offset_length;
+ int err;
+
+ u(2, ct_type, 0, 2);
+ flag(nuit_field_based_flag);
+ u(5, counting_type, 0, 6);
+ flag(full_timestamp_flag);
+ flag(discontinuity_flag);
+ flag(cnt_dropped_flag);
+ u(8, n_frames, 0, 255);
+ if (current->full_timestamp_flag) {
+ u(6, seconds_value, 0, 59);
+ u(6, minutes_value, 0, 59);
+ u(5, hours_value, 0, 23);
+ } else {
+ flag(seconds_flag);
+ if (current->seconds_flag) {
+ u(6, seconds_value, 0, 59);
+ flag(minutes_flag);
+ if (current->minutes_flag) {
+ u(6, minutes_value, 0, 59);
+ flag(hours_flag);
+ if (current->hours_flag)
+ u(5, hours_value, 0, 23);
+ }
+ }
+ }
+
+ sps = ctx->active_sps;
+ if (sps->vui.nal_hrd_parameters_present_flag)
+ time_offset_length = sps->vui.nal_hrd_parameters.time_offset_length;
+ else if (sps->vui.vcl_hrd_parameters_present_flag)
+ time_offset_length = sps->vui.vcl_hrd_parameters.time_offset_length;
+ else
+ time_offset_length = 24;
+
+ if (time_offset_length > 0)
+ u(time_offset_length, time_offset,
+ 0, (1 << (uint64_t)time_offset_length) - 1);
+ else
+ infer(time_offset, 0);
+
+ return 0;
+}
+
+static int FUNC(sei_pic_timing)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIPicTiming *current)
+{
+ const H264RawSPS *sps;
+ int err;
+
+ sps = ctx->active_sps;
+ if (!sps) {
+ av_log(ctx, AV_LOG_ERROR, "No active SPS for pic_timing.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ if (sps->vui.nal_hrd_parameters_present_flag ||
+ sps->vui.vcl_hrd_parameters_present_flag) {
+ const H264RawHRD *hrd;
+
+ if (sps->vui.nal_hrd_parameters_present_flag)
+ hrd = &sps->vui.nal_hrd_parameters;
+ else if (sps->vui.vcl_hrd_parameters_present_flag)
+ hrd = &sps->vui.vcl_hrd_parameters;
+ else {
+ av_log(ctx, AV_LOG_ERROR, "No HRD parameters for pic_timing.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ u(hrd->cpb_removal_delay_length_minus1 + 1, cpb_removal_delay,
+ 0, (1 << (uint64_t)hrd->cpb_removal_delay_length_minus1) + 1);
+ u(hrd->dpb_output_delay_length_minus1 + 1, dpb_output_delay,
+ 0, (1 << (uint64_t)hrd->dpb_output_delay_length_minus1) + 1);
+ }
+
+ if (sps->vui.pic_struct_present_flag) {
+ static const int num_clock_ts[9] = {
+ 1, 1, 1, 2, 2, 3, 3, 2, 3
+ };
+ int i;
+
+ u(4, pic_struct, 0, 8);
+ if (current->pic_struct > 8)
+ return AVERROR_INVALIDDATA;
+
+ for (i = 0; i < num_clock_ts[current->pic_struct]; i++) {
+ flag(clock_timestamp_flag[i]);
+ if (current->clock_timestamp_flag[i])
+ CHECK(FUNC(sei_pic_timestamp)(ctx, rw,
¤t->timestamp[i]));
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(sei_user_data_registered)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIUserDataRegistered
*current,
+ size_t payload_size)
+{
+ int err, i, j;
+
+ u(8, itu_t_t35_country_code, 0x00, 0xff);
+ if (current->itu_t_t35_country_code != 0xff)
+ i = 1;
+ else {
+ u(8, itu_t_t35_country_code_extension_byte, 0x00, 0xff);
+ i = 2;
+ }
+
+ if (payload_size < i) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid SEI user data registered
payload.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ allocate(current->data, payload_size - i);
+ for (j = 0; j < payload_size - i; j++)
+ xu(8, itu_t_t35_payload_byte, current->data[j], 0x00, 0xff);
+
+ return 0;
+}
+
+static int FUNC(sei_user_data_unregistered)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIUserDataUnregistered
*current,
+ size_t payload_size)
+{
+ int err, i;
+
+ if (payload_size < 16) {
+ av_log(ctx, AV_LOG_ERROR, "Invalid SEI user data unregistered
payload.\n");
+ return AVERROR_INVALIDDATA;
+ }
+
+ for (i = 0; i < 16; i++) {
+ xu(8, uuid_iso_iec_11578,
+ current->uuid_iso_iec_11578[i], 0x00, 0xff);
+ }
+
+ allocate(current->data, payload_size - 16);
+
+ for (i = 0; i < payload_size - 16; i++)
+ xu(8, user_data_payload_byte, current->data[i], 0x00, 0xff);
+
+ return 0;
+}
+
+static int FUNC(sei_recovery_point)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIRecoveryPoint *current)
+{
+ int err;
+
+ ue(recovery_frame_cnt, 0, 65535);
+ flag(exact_match_flag);
+ flag(broken_link_flag);
+ u(2, changing_slice_group_idc, 0, 2);
+
+ return 0;
+}
+
+static int FUNC(sei_display_orientation)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIDisplayOrientation *current)
+{
+ int err;
+
+ flag(display_orientation_cancel_flag);
+ if (!current->display_orientation_cancel_flag) {
+ flag(hor_flip);
+ flag(ver_flip);
+ u(16, anticlockwise_rotation, 0, 65535);
+ ue(display_orientation_repetition_period, 0, 16384);
+ flag(display_orientation_extension_flag);
+ }
+
+ return 0;
+}
+
+static int FUNC(sei_payload)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEIPayload *current)
+{
+ int err, i;
+
+ switch (current->payload_type) {
+ case SEI_TYPE_BUFFERING_PERIOD:
+ CHECK(FUNC(sei_buffering_period)(ctx, rw, ¤t->buffering_period));
+ break;
+ case SEI_TYPE_PIC_TIMING:
+ CHECK(FUNC(sei_pic_timing)(ctx, rw, ¤t->pic_timing));
+ break;
+ case SEI_TYPE_FILLER:
+ {
+ int ff_byte = 0xff;
+ for (i = 0; i < current->payload_size; i++)
+ xu(8, ff_byte, ff_byte, 0xff, 0xff);
+ }
+ break;
+ case SEI_TYPE_USER_DATA_REGISTERED:
+ CHECK(FUNC(sei_user_data_registered)
+ (ctx, rw, ¤t->user_data_registered,
current->payload_size));
+ break;
+ case SEI_TYPE_USER_DATA_UNREGISTERED:
+ CHECK(FUNC(sei_user_data_unregistered)
+ (ctx, rw, ¤t->user_data_unregistered,
current->payload_size));
+ break;
+ case SEI_TYPE_RECOVERY_POINT:
+ CHECK(FUNC(sei_recovery_point)(ctx, rw, ¤t->recovery_point));
+ break;
+ case SEI_TYPE_DISPLAY_ORIENTATION:
+ CHECK(FUNC(sei_display_orientation)
+ (ctx, rw, ¤t->display_orientation));
+ break;
+ default:
+ {
+ allocate(current->other.data, current->payload_size);
+ for (i = 0; i < current->payload_size; i++)
+ xu(8, payload_byte, current->other.data[i], 0, 255);
+ }
+ }
+
+ if (byte_alignment(rw)) {
+ int one = 1, zero = 0;
+ xu(1, bit_equal_to_one, one, 1, 1);
+ while (byte_alignment(rw))
+ xu(1, bit_equal_to_zero, zero, 0, 0);
+ }
+
+ return 0;
+}
+
+static int FUNC(sei)(H264RawContext *ctx, RWContext *rw,
+ H264RawSEI *current)
+{
+ int err, k;
+
+ HEADER("Supplemental Enhancement Information");
+
+ u(1, forbidden_zero_bit, 0, 0);
+ u(2, nal_ref_idc, 0, 3);
+ u(5, nal_unit_type, 0, 31);
+
+#ifdef READ
+ for (k = 0; k < MAX_SEI_PAYLOADS; k++) {
+ uint32_t payload_type = 0;
+ uint32_t payload_size = 0;
+ uint32_t tmp;
+
+ while (bitstream_peek(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) {
+ xu(8, ff_byte, tmp, 0xff, 0xff);
+ payload_size += 255;
+ }
+ xu(8, last_payload_size_byte, tmp, 0, 254);
+ payload_size += tmp;
+
+ current->payload[k].payload_type = payload_type;
+ current->payload[k].payload_size = payload_size;
+
+ CHECK(FUNC(sei_payload)(ctx, rw, ¤t->payload[k]));
+
+ if (!h264_raw_read_more_rbsp_data(rw))
+ break;
+ }
+ if (k >= MAX_SEI_PAYLOADS) {
+ av_log(ctx, AV_LOG_ERROR, "Too many payloads in SEI "
+ "message: found %d.\n", k);
+ return AVERROR_INVALIDDATA;
+ }
+ current->payload_count = k + 1;
+#else
+ for (k = 0; k < current->payload_count; k++) {
+ uint32_t tmp;
+
+ tmp = current->payload[k].payload_type;
+ while (tmp >= 255) {
+ xu(8, ff_byte, 0xff, 0xff, 0xff);
+ tmp -= 255;
+ }
+ xu(8, last_payload_type_byte, tmp, 0, 254);
+
+ tmp = current->payload[k].payload_size;
+ while (tmp >= 255) {
+ xu(8, ff_byte, 0xff, 0xff, 0xff);
+ tmp -= 255;
+ }
+ xu(8, last_payload_size_byte, tmp, 0, 254);
+
+ CHECK(FUNC(sei_payload)(ctx, rw, ¤t->payload[k]));
+ }
+#endif
+
+ CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+ return 0;
+}
+
+static int FUNC(aud)(H264RawContext *ctx, RWContext *rw,
+ H264RawAUD *current)
+{
+ int err;
+
+ HEADER("Access Unit Delimiter");
+
+ u(1, forbidden_zero_bit, 0, 0);
+ u(2, nal_ref_idc, 0, 3);
+ u(5, nal_unit_type, 0, 31);
+
+ u(3, primary_pic_type, 0, 7);
+
+ CHECK(FUNC(rbsp_trailing_bits)(ctx, rw));
+
+ return 0;
+}
+
+static int FUNC(ref_pic_list_modification)(H264RawContext *ctx, RWContext *rw,
+ H264RawSliceHeader *current)
+{
+ const H264RawSPS *sps = ctx->active_sps;
+ int err, i, mopn;
+
+ if (current->slice_type % 5 != 2 &&
+ current->slice_type % 5 != 4) {
+ flag(ref_pic_list_modification_flag_l0);
+ if (current->ref_pic_list_modification_flag_l0) {
+ for (i = 0; i < MAX_RPLM; i++) {
+ xue(modification_of_pic_nums_idc,
+ current->rplm_l0[i].modification_of_pic_nums_idc, 0, 3);
+
+ mopn = current->rplm_l0[i].modification_of_pic_nums_idc;
+ if (mopn == 3)
+ break;
+
+ if (mopn == 0 || mopn == 1)
+ xue(abs_diff_pic_num_minus1,
+ current->rplm_l0[i].abs_diff_pic_num_minus1,
+ 0, (1 + current->field_pic_flag) *
+ (1 << (sps->log2_max_frame_num_minus4 + 4)));
+ else if (mopn == 2)
+ xue(long_term_pic_num,
+ current->rplm_l0[i].long_term_pic_num,
+ 0, sps->max_num_ref_frames - 1);
+ }
+ }
+ }
+
+ if (current->slice_type % 5 == 1) {
+ flag(ref_pic_list_modification_flag_l1);
+ if (current->ref_pic_list_modification_flag_l1) {
+ for (i = 0; i < MAX_RPLM; i++) {
+ xue(modification_of_pic_nums_idc,
+ current->rplm_l1[i].modification_of_pic_nums_idc, 0, 3);
+
+ mopn = current->rplm_l1[i].modification_of_pic_nums_idc;
+ if (mopn == 3)
+ break;
+
+ if (mopn == 0 || mopn == 1)
+ xue(abs_diff_pic_num_minus1,
+ current->rplm_l1[i].abs_diff_pic_num_minus1,
+ 0, (1 + current->field_pic_flag) *
+ (1 << (sps->log2_max_frame_num_minus4 + 4)));
+ else if (mopn == 2)
+ xue(long_term_pic_num,
+ current->rplm_l1[i].long_term_pic_num,
+ 0, sps->max_num_ref_frames - 1);
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(pred_weight_table)(H264RawContext *ctx, RWContext *rw,
+ H264RawSliceHeader *current)
+{
+ const H264RawSPS *sps = ctx->active_sps;
+ int chroma;
+ int err, i, j;
+
+ ue(luma_log2_weight_denom, 0, 7);
+
+ chroma = !sps->separate_colour_plane_flag && sps->chroma_format_idc != 0;
+ if (chroma)
+ ue(chroma_log2_weight_denom, 0, 7);
+
+ for (i = 0; i <= current->num_ref_idx_l0_active_minus1; i++) {
+ xu(1, luma_weight_l0_flag,
+ current->pwt_l0[i].luma_weight_l0_flag, 0, 1);
+
+ if (current->pwt_l0[i].luma_weight_l0_flag) {
+ xse(luma_weight_l0[i],
+ current->pwt_l0[i].luma_weight_l0, -128, +127);
+ xse(luma_offset_l0[i],
+ current->pwt_l0[i].luma_offset_l0, -128, +127);
+ }
+ if (chroma) {
+ xu(1, chroma_weight_l0_flag,
+ current->pwt_l0[i].chroma_weight_l0_flag, 0, 1);
+ if (current->pwt_l0[i].chroma_weight_l0_flag) {
+ for (j = 0; j < 2; j++) {
+ xse(chroma_weight_l0[i][j],
+ current->pwt_l0[i].chroma_weight_l0[j], -128, +127);
+ xse(chroma_offset_l0[i][j],
+ current->pwt_l0[i].chroma_offset_l0[j], -128, +127);
+ }
+ }
+ }
+ }
+
+ if (current->slice_type % 5 == 1) {
+ for (i = 0; i <= current->num_ref_idx_l1_active_minus1; i++) {
+ xu(1, luma_weight_l1_flag,
+ current->pwt_l1[i].luma_weight_l1_flag, 0, 1);
+
+ if (current->pwt_l1[i].luma_weight_l1_flag) {
+ xse(luma_weight_l1[i],
+ current->pwt_l1[i].luma_weight_l1, -128, +127);
+ xse(luma_offset_l1[i],
+ current->pwt_l1[i].luma_offset_l1, -128, +127);
+ }
+ if (chroma) {
+ xu(1, chroma_weight_l1_flag,
+ current->pwt_l1[i].chroma_weight_l1_flag, 0, 1);
+ if (current->pwt_l1[i].chroma_weight_l1_flag) {
+ for (j = 0; j < 2; j++) {
+ xse(chroma_weight_l1[i][j],
+ current->pwt_l1[i].chroma_weight_l1[j], -128,
+127);
+ xse(chroma_offset_l1[i][j],
+ current->pwt_l1[i].chroma_offset_l1[j], -128,
+127);
+ }
+ }
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(dec_ref_pic_marking)(H264RawContext *ctx, RWContext *rw,
+ H264RawSliceHeader *current)
+{
+ const H264RawSPS *sps = ctx->active_sps;
+ int err, i;
+ uint32_t mmco;
+
+ if (current->nal_unit_type == 5) {
+ flag(no_output_of_prior_pics_flag);
+ flag(long_term_reference_flag);
+ } else {
+ flag(adaptive_ref_pic_marking_mode_flag);
+ if (current->adaptive_ref_pic_marking_mode_flag) {
+ for (i = 0; i < MAX_MMCO; i++) {
+ xue(memory_management_control_operation,
+ current->mmco[i].memory_management_control_operation,
+ 0, 6);
+
+ mmco = current->mmco[i].memory_management_control_operation;
+ if (mmco == 0)
+ break;
+
+ if (mmco == 1 || mmco == 3)
+ xue(difference_of_pic_nums_minus1,
+ current->mmco[i].difference_of_pic_nums_minus1,
+ 0, INT32_MAX);
+ if (mmco == 2)
+ xue(long_term_pic_num,
+ current->mmco[i].long_term_pic_num,
+ 0, sps->max_num_ref_frames - 1);
+ if (mmco == 3 || mmco == 6)
+ xue(long_term_frame_idx,
+ current->mmco[i].long_term_frame_idx,
+ 0, sps->max_num_ref_frames - 1);
+ if (mmco == 4)
+ xue(max_long_term_frame_idx_plus1,
+ current->mmco[i].max_long_term_frame_idx_plus1,
+ 0, sps->max_num_ref_frames);
+ }
+ if (i == MAX_MMCO) {
+ av_log(ctx, AV_LOG_ERROR, "Too many memory management "
+ "control operations.\n");
+ return AVERROR_INVALIDDATA;
+ }
+ }
+ }
+
+ return 0;
+}
+
+static int FUNC(slice_header)(H264RawContext *ctx, RWContext *rw,
+ H264RawSliceHeader *current)
+{
+ const H264RawSPS *sps;
+ const H264RawPPS *pps;
+ int err;
+ int slice_type_i, slice_type_p, slice_type_b;
+ int slice_type_si, slice_type_sp;
+
+ HEADER("Slice Header");
+
+ u(1, forbidden_zero_bit, 0, 0);
+ u(2, nal_ref_idc, 0, 3);
+ u(5, nal_unit_type, 0, 31);
+
+ ue(first_mb_in_slice, 0, 1048576);
+ ue(slice_type, 0, 9);
+
+ slice_type_i = current->slice_type % 5 == 2;
+ slice_type_p = current->slice_type % 5 == 0;
+ slice_type_b = current->slice_type % 5 == 1;
+ slice_type_si = current->slice_type % 5 == 4;
+ slice_type_sp = current->slice_type % 5 == 3;
+
+ ue(pic_parameter_set_id, 0, 255);
+
+ pps = ctx->pps[current->pic_parameter_set_id];
+ if (!pps) {
+ av_log(ctx, AV_LOG_ERROR, "PPS id %d not available.\n",
+ current->pic_parameter_set_id);
+ return AVERROR_INVALIDDATA;
+ }
+ ctx->active_pps = pps;
+
+ sps = ctx->sps[pps->seq_parameter_set_id];
+ if (!sps) {
+ av_log(ctx, AV_LOG_ERROR, "SPS id %d not available.\n",
+ pps->seq_parameter_set_id);
+ return AVERROR_INVALIDDATA;
+ }
+ ctx->active_sps = sps;
+
+ if (sps->separate_colour_plane_flag)
+ u(2, colour_plane_id, 0, 2);
+
+ u(sps->log2_max_frame_num_minus4 + 4, frame_num,
+ 0, (1 << (sps->log2_max_frame_num_minus4 + 4)) - 1);
+
+ if (!sps->frame_mbs_only_flag) {
+ flag(field_pic_flag);
+ if (current->field_pic_flag)
+ flag(bottom_field_flag);
+ } else {
+ infer(field_pic_flag, 0);
+ }
+
+ if (current->nal_unit_type == 5)
+ ue(idr_pic_id, 0, 65535);
+
+ if (sps->pic_order_cnt_type == 0) {
+ u(sps->log2_max_pic_order_cnt_lsb_minus4 + 4, pic_order_cnt_lsb,
+ 0, (1 << (sps->log2_max_pic_order_cnt_lsb_minus4 + 4)) - 1);
+ if (pps->bottom_field_pic_order_in_frame_present_flag &&
+ !current->field_pic_flag)
+ se(delta_pic_order_cnt_bottom, INT32_MIN + 1, INT32_MAX);
+
+ } else if (sps->pic_order_cnt_type == 1) {
+ if (!sps->delta_pic_order_always_zero_flag) {
+ se(delta_pic_order_cnt[0], INT32_MIN + 1, INT32_MAX);
+ if (pps->bottom_field_pic_order_in_frame_present_flag &&
+ !current->field_pic_flag)
+ se(delta_pic_order_cnt[1], INT32_MIN + 1, INT32_MAX);
+ else
+ infer(delta_pic_order_cnt[1], 0);
+ } else {
+ infer(delta_pic_order_cnt[0], 0);
+ infer(delta_pic_order_cnt[1], 0);
+ }
+ }
+
+ if (pps->redundant_pic_cnt_present_flag)
+ ue(redundant_pic_cnt, 0, 127);
+
+ if (slice_type_b)
+ flag(direct_spatial_mv_pred_flag);
+
+ if (slice_type_p || slice_type_sp || slice_type_b) {
+ flag(num_ref_idx_active_override_flag);
+ if (current->num_ref_idx_active_override_flag) {
+ ue(num_ref_idx_l0_active_minus1, 0, 31);
+ if (slice_type_b)
+ ue(num_ref_idx_l1_active_minus1, 0, 31);
+ } else {
+ infer(num_ref_idx_l0_active_minus1,
+ pps->num_ref_idx_l0_default_active_minus1);
+ infer(num_ref_idx_l1_active_minus1,
+ pps->num_ref_idx_l1_default_active_minus1);
+ }
+ }
+
+ if (current->nal_unit_type == 20 ||
+ current->nal_unit_type == 21) {
+ av_log(ctx, AV_LOG_ERROR, "MVC not supported.\n");
+ return AVERROR_PATCHWELCOME;
+ } else {
+ CHECK(FUNC(ref_pic_list_modification)(ctx, rw, current));
+ }
+
+ if ((pps->weighted_pred_flag && (slice_type_p || slice_type_sp)) ||
+ (pps->weighted_bipred_idc == 1 && slice_type_b)) {
+ CHECK(FUNC(pred_weight_table)(ctx, rw, current));
+ }
+
+ if (current->nal_ref_idc != 0) {
+ CHECK(FUNC(dec_ref_pic_marking)(ctx, rw, current));
+ }
+
+ if (pps->entropy_coding_mode_flag &&
+ !slice_type_i && !slice_type_si) {
+ ue(cabac_init_idc, 0, 2);
+ }
+
+ se(slice_qp_delta, - 51 - 6 * sps->bit_depth_luma_minus8,
+ + 51 + 6 * sps->bit_depth_luma_minus8);
+ if (slice_type_sp || slice_type_si) {
+ if (slice_type_sp)
+ flag(sp_for_switch_flag);
+ se(slice_qs_delta, -51, +51);
+ }
+
+ if (pps->deblocking_filter_control_present_flag) {
+ ue(disable_deblocking_filter_idc, 0, 2);
+ if (current->disable_deblocking_filter_idc != 1) {
+ se(slice_alpha_c0_offset_div2, -6, +6);
+ se(slice_beta_offset_div2, -6, +6);
+ } else {
+ infer(slice_alpha_c0_offset_div2, 0);
+ infer(slice_beta_offset_div2, 0);
+ }
+ } else {
+ infer(disable_deblocking_filter_idc, 0);
+ infer(slice_alpha_c0_offset_div2, 0);
+ infer(slice_beta_offset_div2, 0);
+ }
+
+ if (pps->num_slice_groups_minus1 > 0 &&
+ pps->slice_group_map_type >= 3 &&
+ pps->slice_group_map_type <= 5) {
+ return AVERROR_PATCHWELCOME;
+ }
+
+ if (pps->entropy_coding_mode_flag) {
+ int one = 1;
+#ifdef READ
+ while (bitstream_tell(rw) % 8)
+#else
+ while (put_bits_count(rw) % 8)
+#endif
+ xu(1, cabac_alignment_one_bit, one, 1, 1);
+ }
+
+ return 0;
+}
+
+
+#undef READWRITE
+#undef RWContext
+#undef xu
+#undef xue
+#undef xse
+#undef u
+#undef ue
+#undef se
+#undef infer
+#undef byte_alignment
+#undef allocate
+#undef FUNC3
+#undef FUNC2
+#undef FUNC
diff --git a/libavcodec/h264_sei.h b/libavcodec/h264_sei.h
index 8815aa389..b384cb6e8 100644
--- a/libavcodec/h264_sei.h
+++ b/libavcodec/h264_sei.h
@@ -27,6 +27,7 @@
typedef enum {
SEI_TYPE_BUFFERING_PERIOD = 0, ///< buffering period (H.264, D.1.1)
SEI_TYPE_PIC_TIMING = 1, ///< picture timing
+ SEI_TYPE_FILLER = 3, ///< filler
SEI_TYPE_USER_DATA_REGISTERED = 4, ///< registered user data as
specified by Rec. ITU-T T.35
SEI_TYPE_USER_DATA_UNREGISTERED = 5, ///< unregistered user data
SEI_TYPE_RECOVERY_POINT = 6, ///< recovery point (frame # to
decoder sync)
--
2.11.0
_______________________________________________
libav-devel mailing list
[email protected]
https://lists.libav.org/mailman/listinfo/libav-devel
