falkTX
/
FFmpeg
mirror of https://github.com/falkTX/FFmpeg.git
1
0
Fork 0
Code Issues 0 Releases 338 Wiki Activity
Browse Source

lavc: Add coded bitstream read/write support for MPEG-2 

Also enable MPEG-2 support in the trace_headers filter.
tags/n4.0
Mark Thompson 8 years ago
parent
768eb9182e
commit
2bc9ba8d3c
9 changed files with 975 additions and 2 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +3
    -1
      configure
  2. +1
    -1
      doc/bitstream_filters.texi
  3. +1
    -0
      libavcodec/Makefile
  4. +3
    -0
      libavcodec/cbs.c
  5. +1
    -0
      libavcodec/cbs_internal.h
  6. +409
    -0
      libavcodec/cbs_mpeg2.c
  7. +216
    -0
      libavcodec/cbs_mpeg2.h
  8. +340
    -0
      libavcodec/cbs_mpeg2_syntax_template.c
  9. +1
    -0
      libavcodec/trace_headers_bsf.c

+ 3
- 1
configure View File

@@ -1742,6 +1742,7 @@ CONFIG_EXTRA="
cbs
cbs_h264
cbs_h265
cbs_mpeg2
dirac_parse
dvprofile
faandct
@@ -1970,6 +1971,7 @@ threads_if_any="$THREADS_LIST"
# subsystems
cbs_h264_select="cbs golomb"
cbs_h265_select="cbs golomb"
cbs_mpeg2_select="cbs"
dct_select="rdft"
dirac_parse_select="golomb"
error_resilience_select="me_cmp"
@@ -2327,7 +2329,7 @@ h264_metadata_bsf_select="cbs_h264"
h264_redundant_pps_bsf_select="cbs_h264"
hevc_metadata_bsf_select="cbs_h265"
mjpeg2jpeg_bsf_select="jpegtables"
trace_headers_bsf_select="cbs_h264 cbs_h265"
trace_headers_bsf_select="cbs_h264 cbs_h265 cbs_mpeg2"

# external libraries
avisynth_deps="LoadLibrary"


+ 1
- 1
doc/bitstream_filters.texi View File

@@ -227,7 +227,7 @@ Log trace output containing all syntax elements in the coded stream
headers (everything above the level of individual coded blocks).
This can be useful for debugging low-level stream issues.

Supports H.264 and H.265.
Supports H.264, H.265 and MPEG-2.

@section vp9_superframe



+ 1
- 0
libavcodec/Makefile View File

@@ -56,6 +56,7 @@ OBJS-$(CONFIG_CABAC) += cabac.o
OBJS-$(CONFIG_CBS) += cbs.o
OBJS-$(CONFIG_CBS_H264) += cbs_h2645.o h2645_parse.o
OBJS-$(CONFIG_CBS_H265) += cbs_h2645.o h2645_parse.o
OBJS-$(CONFIG_CBS_MPEG2) += cbs_mpeg2.o
OBJS-$(CONFIG_DCT) += dct.o dct32_fixed.o dct32_float.o
OBJS-$(CONFIG_ERROR_RESILIENCE) += error_resilience.o
OBJS-$(CONFIG_FAANDCT) += faandct.o


+ 3
- 0
libavcodec/cbs.c View File

@@ -34,6 +34,9 @@ static const CodedBitstreamType *cbs_type_table[] = {
#if CONFIG_CBS_H265
&ff_cbs_type_h265,
#endif
#if CONFIG_CBS_MPEG2
&ff_cbs_type_mpeg2,
#endif
};

int ff_cbs_init(CodedBitstreamContext *ctx,


+ 1
- 0
libavcodec/cbs_internal.h View File

@@ -82,6 +82,7 @@ int ff_cbs_write_unsigned(CodedBitstreamContext *ctx, PutBitContext *pbc,

extern const CodedBitstreamType ff_cbs_type_h264;
extern const CodedBitstreamType ff_cbs_type_h265;
extern const CodedBitstreamType ff_cbs_type_mpeg2;


#endif /* AVCODEC_CBS_INTERNAL_H */

+ 409
- 0
libavcodec/cbs_mpeg2.c View File

@@ -0,0 +1,409 @@
/*
* 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 "cbs.h"
#include "cbs_internal.h"
#include "cbs_mpeg2.h"
#include "internal.h"


#define HEADER(name) do { \
ff_cbs_trace_header(ctx, name); \
} while (0)

#define CHECK(call) do { \
err = (call); \
if (err < 0) \
return err; \
} while (0)

#define FUNC_NAME(rw, codec, name) cbs_ ## codec ## _ ## rw ## _ ## name
#define FUNC_MPEG2(rw, name) FUNC_NAME(rw, mpeg2, name)
#define FUNC(name) FUNC_MPEG2(READWRITE, name)


#define READ
#define READWRITE read
#define RWContext BitstreamContext

#define xui(width, name, var) do { \
uint32_t value = 0; \
CHECK(ff_cbs_read_unsigned(ctx, rw, width, #name, \
&value, 0, (1 << width) - 1)); \
var = value; \
} while (0)

#define ui(width, name) \
xui(width, name, current->name)

#define marker_bit() do { \
av_unused int one = 1; \
CHECK(ff_cbs_read_unsigned(ctx, rw, 1, "marker_bit", &one, 1, 1)); \
} while (0)

#define nextbits(width, compare, var) (var = bitstream_peek(rw, width), \
var == (compare))

#include "cbs_mpeg2_syntax_template.c"

#undef READ
#undef READWRITE
#undef RWContext
#undef xui
#undef ui
#undef marker_bit
#undef nextbits


#define WRITE
#define READWRITE write
#define RWContext PutBitContext

#define xui(width, name, var) do { \
CHECK(ff_cbs_write_unsigned(ctx, rw, width, #name, \
var, 0, (1 << width) - 1)); \
} while (0)

#define ui(width, name) \
xui(width, name, current->name)

#define marker_bit() do { \
CHECK(ff_cbs_write_unsigned(ctx, rw, 1, "marker_bit", 1, 1, 1)); \
} while (0)

#define nextbits(width, compare, var) (var)

#include "cbs_mpeg2_syntax_template.c"

#undef READ
#undef READWRITE
#undef RWContext
#undef xui
#undef ui
#undef marker_bit
#undef nextbits


static int cbs_mpeg2_split_fragment(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag,
int header)
{
const uint8_t *start, *end;
uint8_t *unit_data;
uint32_t start_code = -1, next_start_code = -1;
size_t unit_size;
int err, i, unit_type;

start = avpriv_find_start_code(frag->data, frag->data + frag->data_size,
&start_code);
for (i = 0;; i++) {
end = avpriv_find_start_code(start, frag->data + frag->data_size,
&next_start_code);

unit_type = start_code & 0xff;

// The start and end pointers point at to the byte following the
// start_code_identifier in the start code that they found.
if (end == frag->data + frag->data_size) {
// We didn't find a start code, so this is the final unit.
unit_size = end - (start - 1);
} else {
// Unit runs from start to the beginning of the start code
// pointed to by end (including any padding zeroes).
unit_size = (end - 4) - (start - 1);
}

unit_data = av_malloc(unit_size);
if (!unit_data)
return AVERROR(ENOMEM);
memcpy(unit_data, start - 1, unit_size);

err = ff_cbs_insert_unit_data(ctx, frag, i, unit_type,
unit_data, unit_size);
if (err < 0) {
av_freep(&unit_data);
return err;
}

if (end == frag->data + frag->data_size)
break;

start_code = next_start_code;
start = end;
}

return 0;
}

static int cbs_mpeg2_read_unit(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit)
{
BitstreamContext bc;
int err;

err = bitstream_init(&bc, unit->data, 8 * unit->data_size);
if (err < 0)
return err;

if (MPEG2_START_IS_SLICE(unit->type)) {
MPEG2RawSlice *slice;
int pos, len;

slice = av_mallocz(sizeof(*slice));
if (!slice)
return AVERROR(ENOMEM);
err = cbs_mpeg2_read_slice_header(ctx, &bc, &slice->header);
if (err < 0) {
av_free(slice);
return err;
}

pos = bitstream_tell(&bc);
len = unit->data_size;

slice->data_size = len - pos / 8;
slice->data = av_malloc(slice->data_size);
if (!slice->data) {
av_free(slice);
return AVERROR(ENOMEM);
}

memcpy(slice->data,
unit->data + pos / 8, slice->data_size);
slice->data_bit_start = pos % 8;

unit->content = slice;

} else {
switch (unit->type) {
#define START(start_code, type, func) \
case start_code: \
{ \
type *header; \
header = av_mallocz(sizeof(*header)); \
if (!header) \
return AVERROR(ENOMEM); \
err = cbs_mpeg2_read_ ## func(ctx, &bc, header); \
if (err < 0) { \
av_free(header); \
return err; \
} \
unit->content = header; \
} \
break;
START(0x00, MPEG2RawPictureHeader, picture_header);
START(0xb2, MPEG2RawUserData, user_data);
START(0xb3, MPEG2RawSequenceHeader, sequence_header);
START(0xb5, MPEG2RawExtensionData, extension_data);
START(0xb8, MPEG2RawGroupOfPicturesHeader, group_of_pictures_header);
#undef START
default:
av_log(ctx->log_ctx, AV_LOG_ERROR, "Unknown start code %02x.\n",
unit->type);
return AVERROR_INVALIDDATA;
}
}

return 0;
}

static int cbs_mpeg2_write_header(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit,
PutBitContext *pbc)
{
int err;

switch (unit->type) {
#define START(start_code, type, func) \
case start_code: \
err = cbs_mpeg2_write_ ## func(ctx, pbc, unit->content); \
break;
START(0x00, MPEG2RawPictureHeader, picture_header);
START(0xb2, MPEG2RawUserData, user_data);
START(0xb3, MPEG2RawSequenceHeader, sequence_header);
START(0xb5, MPEG2RawExtensionData, extension_data);
START(0xb8, MPEG2RawGroupOfPicturesHeader, group_of_pictures_header);
#undef START
default:
av_log(ctx->log_ctx, AV_LOG_ERROR, "Write unimplemented for start "
"code %02x.\n", unit->type);
return AVERROR_PATCHWELCOME;
}

return err;
}

static int cbs_mpeg2_write_slice(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit,
PutBitContext *pbc)
{
MPEG2RawSlice *slice = unit->content;
BitstreamContext bc;
size_t bits_left;
int err;

err = cbs_mpeg2_write_slice_header(ctx, pbc, &slice->header);
if (err < 0)
return err;

if (slice->data) {
if (slice->data_size * 8 + 8 > put_bits_left(pbc))
return AVERROR(ENOSPC);

bitstream_init(&bc, slice->data, slice->data_size * 8);
bitstream_skip(&bc, slice->data_bit_start);

while (bitstream_bits_left(&bc) > 15)
put_bits(pbc, 16, bitstream_read(&bc, 16));

bits_left = bitstream_bits_left(&bc);
put_bits(pbc, bits_left, bitstream_read(&bc, bits_left));

// Align with zeroes.
while (put_bits_count(pbc) % 8 != 0)
put_bits(pbc, 1, 0);
}

return 0;
}

static int cbs_mpeg2_write_unit(CodedBitstreamContext *ctx,
CodedBitstreamUnit *unit)
{
CodedBitstreamMPEG2Context *priv = ctx->priv_data;
PutBitContext pbc;
int err;

if (!priv->write_buffer) {
// Initial write buffer size is 1MB.
priv->write_buffer_size = 1024 * 1024;

reallocate_and_try_again:
err = av_reallocp(&priv->write_buffer, priv->write_buffer_size);
if (err < 0) {
av_log(ctx->log_ctx, AV_LOG_ERROR, "Unable to allocate a "
"sufficiently large write buffer (last attempt "
"%zu bytes).\n", priv->write_buffer_size);
return err;
}
}

init_put_bits(&pbc, priv->write_buffer, priv->write_buffer_size);

if (unit->type >= 0x01 && unit->type <= 0xaf)
err = cbs_mpeg2_write_slice(ctx, unit, &pbc);
else
err = cbs_mpeg2_write_header(ctx, unit, &pbc);

if (err == AVERROR(ENOSPC)) {
// Overflow.
priv->write_buffer_size *= 2;
goto reallocate_and_try_again;
}
if (err < 0) {
// Write failed for some other reason.
return err;
}

if (put_bits_count(&pbc) % 8)
unit->data_bit_padding = 8 - put_bits_count(&pbc) % 8;
else
unit->data_bit_padding = 0;

unit->data_size = (put_bits_count(&pbc) + 7) / 8;
flush_put_bits(&pbc);

err = av_reallocp(&unit->data, unit->data_size);
if (err < 0)
return err;

memcpy(unit->data, priv->write_buffer, unit->data_size);

return 0;
}

static int cbs_mpeg2_assemble_fragment(CodedBitstreamContext *ctx,
CodedBitstreamFragment *frag)
{
uint8_t *data;
size_t size, dp, sp;
int i;

size = 0;
for (i = 0; i < frag->nb_units; i++)
size += 3 + frag->units[i].data_size;

data = av_malloc(size);
if (!data)
return AVERROR(ENOMEM);

dp = 0;
for (i = 0; i < frag->nb_units; i++) {
CodedBitstreamUnit *unit = &frag->units[i];

data[dp++] = 0;
data[dp++] = 0;
data[dp++] = 1;

for (sp = 0; sp < unit->data_size; sp++)
data[dp++] = unit->data[sp];
}

av_assert0(dp == size);

frag->data = data;
frag->data_size = size;

return 0;
}

static void cbs_mpeg2_free_unit(CodedBitstreamUnit *unit)
{
if (MPEG2_START_IS_SLICE(unit->type)) {
MPEG2RawSlice *slice = unit->content;
av_freep(&slice->data);
av_freep(&slice->header.extra_information);
} else if (unit->type == MPEG2_START_USER_DATA) {
MPEG2RawUserData *user = unit->content;
av_freep(&user->user_data);
}
av_freep(&unit->content);
}

static void cbs_mpeg2_close(CodedBitstreamContext *ctx)
{
CodedBitstreamMPEG2Context *priv = ctx->priv_data;

av_freep(&priv->write_buffer);
}

const CodedBitstreamType ff_cbs_type_mpeg2 = {
.codec_id = AV_CODEC_ID_MPEG2VIDEO,

.priv_data_size = sizeof(CodedBitstreamMPEG2Context),

.split_fragment = &cbs_mpeg2_split_fragment,
.read_unit = &cbs_mpeg2_read_unit,
.write_unit = &cbs_mpeg2_write_unit,
.assemble_fragment = &cbs_mpeg2_assemble_fragment,

.free_unit = &cbs_mpeg2_free_unit,
.close = &cbs_mpeg2_close,
};

+ 216
- 0
libavcodec/cbs_mpeg2.h View File

@@ -0,0 +1,216 @@
/*
* 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_CBS_MPEG2_H
#define AVCODEC_CBS_MPEG2_H

#include <stddef.h>
#include <stdint.h>


enum {
MPEG2_START_PICTURE = 0x00,
MPEG2_START_SLICE_MIN = 0x01,
MPEG2_START_SLICE_MAX = 0xaf,
MPEG2_START_USER_DATA = 0xb2,
MPEG2_START_SEQUENCE_HEADER = 0xb3,
MPEG2_START_SEQUENCE_ERROR = 0xb4,
MPEG2_START_EXTENSION = 0xb5,
MPEG2_START_SEQUENCE_END = 0xb7,
MPEG2_START_GROUP = 0xb8,
};

#define MPEG2_START_IS_SLICE(type) \
((type) >= MPEG2_START_SLICE_MIN && \
(type) <= MPEG2_START_SLICE_MAX)

enum {
MPEG2_EXTENSION_SEQUENCE = 0x1,
MPEG2_EXTENSION_SEQUENCE_DISPLAY = 0x2,
MPEG2_EXTENSION_QUANT_MATRIX = 0x3,
MPEG2_EXTENSION_COPYRIGHT = 0x4,
MPEG2_EXTENSION_SEQUENCE_SCALABLE = 0x5,
MPEG2_EXTENSION_PICTURE_DISPLAY = 0x7,
MPEG2_EXTENSION_PICTURE_CODING = 0x8,
MPEG2_EXTENSION_PICTURE_SPATIAL_SCALABLE = 0x9,
MPEG2_EXTENSION_PICTURE_TEMPORAL_SCALABLE = 0xa,
MPEG2_EXTENSION_CAMAERA_PARAMETERS = 0xb,
MPEG2_EXTENSION_ITU_T = 0xc,
};


typedef struct MPEG2RawSequenceHeader {
uint8_t sequence_header_code;

uint16_t horizontal_size_value;
uint16_t vertical_size_value;
uint8_t aspect_ratio_information;
uint8_t frame_rate_code;
uint32_t bit_rate_value;
uint16_t vbv_buffer_size_value;
uint8_t constrained_parameters_flag;

uint8_t load_intra_quantiser_matrix;
uint8_t intra_quantiser_matrix[64];
uint8_t load_non_intra_quantiser_matrix;
uint8_t non_intra_quantiser_matrix[64];
} MPEG2RawSequenceHeader;

typedef struct MPEG2RawUserData {
uint8_t user_data_start_code;

uint8_t *user_data;
size_t user_data_length;
} MPEG2RawUserData;

typedef struct MPEG2RawSequenceExtension {
uint8_t profile_and_level_indication;
uint8_t progressive_sequence;
uint8_t chroma_format;
uint8_t horizontal_size_extension;
uint8_t vertical_size_extension;
uint16_t bit_rate_extension;
uint8_t vbv_buffer_size_extension;
uint8_t low_delay;
uint8_t frame_rate_extension_n;
uint8_t frame_rate_extension_d;
} MPEG2RawSequenceExtension;

typedef struct MPEG2RawSequenceDisplayExtension {
uint8_t video_format;

uint8_t colour_description;
uint8_t colour_primaries;
uint8_t transfer_characteristics;
uint8_t matrix_coefficients;

uint16_t display_horizontal_size;
uint16_t display_vertical_size;
} MPEG2RawSequenceDisplayExtension;

typedef struct MPEG2RawGroupOfPicturesHeader {
uint8_t group_start_code;

uint32_t time_code;
uint8_t closed_gop;
uint8_t broken_link;
} MPEG2RawGroupOfPicturesHeader;

typedef struct MPEG2RawPictureHeader {
uint8_t picture_start_code;

uint16_t temporal_reference;
uint8_t picture_coding_type;
uint16_t vbv_delay;

uint8_t full_pel_forward_vector;
uint8_t forward_f_code;
uint8_t full_pel_backward_vector;
uint8_t backward_f_code;

uint8_t extra_bit_picture;
} MPEG2RawPictureHeader;

typedef struct MPEG2RawPictureCodingExtension {
uint8_t f_code[2][2];

uint8_t intra_dc_precision;
uint8_t picture_structure;
uint8_t top_field_first;
uint8_t frame_pred_frame_dct;
uint8_t concealment_motion_vectors;
uint8_t q_scale_type;
uint8_t intra_vlc_format;
uint8_t alternate_scan;
uint8_t repeat_first_field;
uint8_t chroma_420_type;
uint8_t progressive_frame;

uint8_t composite_display_flag;
uint8_t v_axis;
uint8_t field_sequence;
uint8_t sub_carrier;
uint8_t burst_amplitude;
uint8_t sub_carrier_phase;
} MPEG2RawPictureCodingExtension;

typedef struct MPEG2RawQuantMatrixExtension {
uint8_t load_intra_quantiser_matrix;
uint8_t intra_quantiser_matrix[64];
uint8_t load_non_intra_quantiser_matrix;
uint8_t non_intra_quantiser_matrix[64];
uint8_t load_chroma_intra_quantiser_matrix;
uint8_t chroma_intra_quantiser_matrix[64];
uint8_t load_chroma_non_intra_quantiser_matrix;
uint8_t chroma_non_intra_quantiser_matrix[64];
} MPEG2RawQuantMatrixExtension;

typedef struct MPEG2RawExtensionData {
uint8_t extension_start_code;
uint8_t extension_start_code_identifier;

union {
MPEG2RawSequenceExtension sequence;
MPEG2RawSequenceDisplayExtension sequence_display;
MPEG2RawQuantMatrixExtension quant_matrix;
MPEG2RawPictureCodingExtension picture_coding;
} data;
} MPEG2RawExtensionData;

typedef struct MPEG2RawSliceHeader {
uint8_t slice_vertical_position;

uint8_t slice_vertical_position_extension;
uint8_t priority_breakpoint;

uint8_t quantiser_scale_code;

uint8_t slice_extension_flag;
uint8_t intra_slice;
uint8_t slice_picture_id_enable;
uint8_t slice_picture_id;

uint8_t extra_bit_slice;

size_t extra_information_length;
uint8_t *extra_information;
} MPEG2RawSliceHeader;

typedef struct MPEG2RawSlice {
MPEG2RawSliceHeader header;

uint8_t *data;
size_t data_size;
int data_bit_start;
} MPEG2RawSlice;


typedef struct CodedBitstreamMPEG2Context {
// Elements stored in headers which are required for other decoding.
uint16_t horizontal_size;
uint16_t vertical_size;
uint8_t scalable;
uint8_t scalable_mode;

// Write buffer.
uint8_t *write_buffer;
size_t write_buffer_size;
} CodedBitstreamMPEG2Context;


#endif /* AVCODEC_CBS_MPEG2_H */

+ 340
- 0
libavcodec/cbs_mpeg2_syntax_template.c View File

@@ -0,0 +1,340 @@
/*
* 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
*/

static int FUNC(sequence_header)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawSequenceHeader *current)
{
CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
int err, i;

HEADER("Sequence Header");

ui(8, sequence_header_code);

ui(12, horizontal_size_value);
ui(12, vertical_size_value);

mpeg2->horizontal_size = current->horizontal_size_value;
mpeg2->vertical_size = current->vertical_size_value;

ui(4, aspect_ratio_information);
ui(4, frame_rate_code);
ui(18, bit_rate_value);

marker_bit();

ui(10, vbv_buffer_size_value);
ui(1, constrained_parameters_flag);

ui(1, load_intra_quantiser_matrix);
if (current->load_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, intra_quantiser_matrix[i]);
}

ui(1, load_non_intra_quantiser_matrix);
if (current->load_non_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, non_intra_quantiser_matrix[i]);
}

return 0;
}

static int FUNC(user_data)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawUserData *current)
{
size_t k;
int err;

HEADER("User Data");

ui(8, user_data_start_code);

#ifdef READ
k = bitstream_bits_left(rw);
av_assert0(k % 8 == 0);
current->user_data_length = k /= 8;
if (k > 0) {
current->user_data = av_malloc(k);
if (!current->user_data)
return AVERROR(ENOMEM);
}
#endif

for (k = 0; k < current->user_data_length; k++)
xui(8, user_data, current->user_data[k]);

return 0;
}

static int FUNC(sequence_extension)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawSequenceExtension *current)
{
CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
int err;

HEADER("Sequence Extension");

ui(8, profile_and_level_indication);
ui(1, progressive_sequence);
ui(2, chroma_format);
ui(2, horizontal_size_extension);
ui(2, vertical_size_extension);

mpeg2->horizontal_size = (mpeg2->horizontal_size & 0xfff) |
current->horizontal_size_extension << 12;
mpeg2->vertical_size = (mpeg2->vertical_size & 0xfff) |
current->vertical_size_extension << 12;

ui(12, bit_rate_extension);
marker_bit();
ui(8, vbv_buffer_size_extension);
ui(1, low_delay);
ui(2, frame_rate_extension_n);
ui(5, frame_rate_extension_d);

return 0;
}

static int FUNC(sequence_display_extension)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawSequenceDisplayExtension *current)
{
int err;

HEADER("Sequence Display Extension");

ui(3, video_format);

ui(1, colour_description);
if (current->colour_description) {
ui(8, colour_primaries);
ui(8, transfer_characteristics);
ui(8, matrix_coefficients);
}

ui(14, display_horizontal_size);
marker_bit();
ui(14, display_vertical_size);

return 0;
}

static int FUNC(group_of_pictures_header)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawGroupOfPicturesHeader *current)
{
int err;

HEADER("Group of Pictures Header");

ui(8, group_start_code);

ui(25, time_code);
ui(1, closed_gop);
ui(1, broken_link);

return 0;
}

static int FUNC(picture_header)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawPictureHeader *current)
{
int err;

HEADER("Picture Header");

ui(8, picture_start_code);

ui(10, temporal_reference);
ui(3, picture_coding_type);
ui(16, vbv_delay);

if (current->picture_coding_type == 2 ||
current->picture_coding_type == 3) {
ui(1, full_pel_forward_vector);
ui(3, forward_f_code);
}

if (current->picture_coding_type == 3) {
ui(1, full_pel_backward_vector);
ui(3, backward_f_code);
}

ui(1, extra_bit_picture);

return 0;
}

static int FUNC(picture_coding_extension)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawPictureCodingExtension *current)
{
int err;

HEADER("Picture Coding Extension");

ui(4, f_code[0][0]);
ui(4, f_code[0][1]);
ui(4, f_code[1][0]);
ui(4, f_code[1][1]);

ui(2, intra_dc_precision);
ui(2, picture_structure);
ui(1, top_field_first);
ui(1, frame_pred_frame_dct);
ui(1, concealment_motion_vectors);
ui(1, q_scale_type);
ui(1, intra_vlc_format);
ui(1, alternate_scan);
ui(1, repeat_first_field);
ui(1, chroma_420_type);
ui(1, progressive_frame);

ui(1, composite_display_flag);
if (current->composite_display_flag) {
ui(1, v_axis);
ui(3, field_sequence);
ui(1, sub_carrier);
ui(7, burst_amplitude);
ui(8, sub_carrier_phase);
}

return 0;
}

static int FUNC(quant_matrix_extension)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawQuantMatrixExtension *current)
{
int err, i;

HEADER("Quant Matrix Extension");

ui(1, load_intra_quantiser_matrix);
if (current->load_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, intra_quantiser_matrix[i]);
}

ui(1, load_non_intra_quantiser_matrix);
if (current->load_non_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, non_intra_quantiser_matrix[i]);
}

ui(1, load_chroma_intra_quantiser_matrix);
if (current->load_chroma_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, intra_quantiser_matrix[i]);
}

ui(1, load_chroma_non_intra_quantiser_matrix);
if (current->load_chroma_non_intra_quantiser_matrix) {
for (i = 0; i < 64; i++)
ui(8, chroma_non_intra_quantiser_matrix[i]);
}

return 0;
}

static int FUNC(extension_data)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawExtensionData *current)
{
int err;

HEADER("Extension Data");

ui(8, extension_start_code);
ui(4, extension_start_code_identifier);

switch (current->extension_start_code_identifier) {
case 1:
return FUNC(sequence_extension)
(ctx, rw, &current->data.sequence);
case 2:
return FUNC(sequence_display_extension)
(ctx, rw, &current->data.sequence_display);
case 3:
return FUNC(quant_matrix_extension)
(ctx, rw, &current->data.quant_matrix);
case 8:
return FUNC(picture_coding_extension)
(ctx, rw, &current->data.picture_coding);
default:
av_log(ctx->log_ctx, AV_LOG_ERROR, "Invalid extension ID %d.\n",
current->extension_start_code_identifier);
return AVERROR_INVALIDDATA;
}
}

static int FUNC(slice_header)(CodedBitstreamContext *ctx, RWContext *rw,
MPEG2RawSliceHeader *current)
{
CodedBitstreamMPEG2Context *mpeg2 = ctx->priv_data;
int err;

HEADER("Slice Header");

ui(8, slice_vertical_position);

if (mpeg2->vertical_size > 2800)
ui(3, slice_vertical_position_extension);
if (mpeg2->scalable) {
if (mpeg2->scalable_mode == 0)
ui(7, priority_breakpoint);
}

ui(5, quantiser_scale_code);

if (nextbits(1, 1, current->slice_extension_flag)) {
ui(1, slice_extension_flag);
ui(1, intra_slice);
ui(1, slice_picture_id_enable);
ui(6, slice_picture_id);

{
size_t k;
#ifdef READ
BitstreamContext start;
uint8_t bit;
start = *rw;
for (k = 0; nextbits(1, 1, bit); k++)
bitstream_skip(rw, 8);
current->extra_information_length = k;
if (k > 0) {
*rw = start;
current->extra_information =
av_malloc(current->extra_information_length);
if (!current->extra_information)
return AVERROR(ENOMEM);
for (k = 0; k < current->extra_information_length; k++) {
xui(1, extra_bit_slice, bit);
xui(8, extra_information_slice,
current->extra_information[k]);
}
}
#else
for (k = 0; k < current->extra_information_length; k++) {
xui(1, extra_bit_slice, 1);
xui(8, extra_information_slice, current->extra_information[k]);
}
#endif
}
}
ui(1, extra_bit_slice);

return 0;
}

+ 1
- 0
libavcodec/trace_headers_bsf.c View File

@@ -112,6 +112,7 @@ static int trace_headers(AVBSFContext *bsf, AVPacket *out)
static const enum AVCodecID trace_headers_codec_ids[] = {
AV_CODEC_ID_H264,
AV_CODEC_ID_HEVC,
AV_CODEC_ID_MPEG2VIDEO,
AV_CODEC_ID_NONE,
};



Write Preview
Loading…
Cancel
Save