mirror of
https://git.ffmpeg.org/ffmpeg.git
synced 2024-09-16 19:43:37 +00:00
c9fe9fb863
This commit adds support for VP8 bitstream read methods to the cbs codec. This enables the trace_headers bitstream filter to support VP8, in addition to AV1, H.264, H.265, and VP9. This can be useful for debugging VP8 stream issues. The CBS VP8 implements a simple VP8 boolean decoder using GetBitContext to read the bitstream. Only the read methods `read_unit` and `split_fragment` are implemented. The write methods `write_unit` and `assemble_fragment` return the error code AVERROR_PATCHWELCOME. This is because CBS VP8 write is unlikely to be used by any applications at the moment. The write methods can be added later if there is a real need for them. TESTS: ffmpeg -i fate-suite/vp8/frame_size_change.webm -vcodec copy -bsf:v trace_headers -f null - Signed-off-by: Jianhui Dai <jianhui.j.dai@intel.com> Signed-off-by: Ronald S. Bultje <rsbultje@gmail.com>
249 lines
7.6 KiB
C
249 lines
7.6 KiB
C
/*
|
|
* This file is part of FFmpeg.
|
|
*
|
|
* FFmpeg 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.
|
|
*
|
|
* FFmpeg 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 FFmpeg; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
|
|
*/
|
|
|
|
static int FUNC(update_segmentation)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
bc_f(1, update_segment_map);
|
|
bc_f(1, update_segment_feature_data);
|
|
|
|
if (current->update_segment_feature_data) {
|
|
bc_f(1, segment_feature_mode);
|
|
// quantizer
|
|
for (int i = 0; i < 4; i++) {
|
|
bc_b(segment_qp_update[i]);
|
|
if (current->segment_qp_update[i])
|
|
bc_ss(7, segment_qp[i], 1, i);
|
|
}
|
|
// loop filter
|
|
for (int i = 0; i < 4; i++) {
|
|
bc_b(segment_loop_filter_level_update[i]);
|
|
if (current->segment_loop_filter_level_update[i])
|
|
bc_ss(6, segment_loop_filter_level[i], 1, i);
|
|
}
|
|
}
|
|
|
|
if (current->update_segment_map) {
|
|
for (int i = 0; i < 3; i++) {
|
|
bc_b(segment_probs_update[i]);
|
|
if (current->segment_probs_update[i])
|
|
bc_fs(8, segment_probs[i], 1, i);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(mode_ref_lf_deltas)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
bc_f(1, mode_ref_lf_delta_enable);
|
|
if (current->mode_ref_lf_delta_enable) {
|
|
bc_b(mode_ref_lf_delta_update);
|
|
if (current->mode_ref_lf_delta_update) {
|
|
// ref_lf_deltas
|
|
for (int i = 0; i < 4; i++) {
|
|
bc_b(ref_lf_deltas_update[i]);
|
|
if (current->ref_lf_deltas_update[i])
|
|
bc_ss(6, ref_lf_deltas[i], 1, i);
|
|
}
|
|
// mode_lf_deltas
|
|
for (int i = 0; i < 4; i++) {
|
|
bc_b(mode_lf_deltas_update[i]);
|
|
if (current->mode_lf_deltas_update[i])
|
|
bc_ss(6, mode_lf_deltas[i], 1, i);
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(quantization_params)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
bc_f(7, base_qindex);
|
|
|
|
bc_b(y1dc_delta_q_present);
|
|
if (current->y1dc_delta_q_present)
|
|
bc_s(4, y1dc_delta_q);
|
|
|
|
bc_b(y2dc_delta_q_present);
|
|
if (current->y2dc_delta_q_present)
|
|
bc_s(4, y2dc_delta_q);
|
|
|
|
bc_b(y2ac_delta_q_present);
|
|
if (current->y2ac_delta_q_present)
|
|
bc_s(4, y2ac_delta_q);
|
|
|
|
bc_b(uvdc_delta_q_present);
|
|
if (current->uvdc_delta_q_present)
|
|
bc_s(4, uvdc_delta_q);
|
|
|
|
bc_b(uvac_delta_q_present);
|
|
if (current->uvac_delta_q_present)
|
|
bc_s(4, uvac_delta_q);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(update_token_probs)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
for (int i = 0; i < 4; ++i) {
|
|
for (int j = 0; j < 8; ++j) {
|
|
for (int k = 0; k < 3; ++k) {
|
|
for (int l = 0; l < 11; ++l) {
|
|
bc_b_prob(ff_vp8_token_update_probs[i][j][k][l],
|
|
coeff_prob_update[i][j][k][l]);
|
|
if (current->coeff_prob_update[i][j][k][l])
|
|
bc_fs(8, coeff_prob[i][j][k][l], 4, i, j, k, l);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(update_mv_probs)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
for (int i = 0; i < 2; ++i) {
|
|
for (int j = 0; j < 19; ++j) {
|
|
bc_b(mv_prob_update[i][j]);
|
|
if (current->mv_prob_update[i][j])
|
|
bc_fs(7, mv_prob[i][j], 2, i, j);
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(frame_tag)(CodedBitstreamContext *ctx, RWContext *rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
f(1, frame_type);
|
|
f(3, profile);
|
|
f(1, show_frame);
|
|
f(19, first_partition_length_in_bytes);
|
|
|
|
if (current->frame_type == VP8_KEY_FRAME) {
|
|
fixed(8, start_code_0, VP8_START_CODE_0);
|
|
fixed(8, start_code_1, VP8_START_CODE_1);
|
|
fixed(8, start_code_2, VP8_START_CODE_2);
|
|
|
|
f(14, width);
|
|
f(2, horizontal_scale);
|
|
f(14, height);
|
|
f(2, vertical_scale);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(frame_header)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrameHeader *current)
|
|
{
|
|
if (current->frame_type == VP8_KEY_FRAME) {
|
|
bc_f(1, color_space);
|
|
bc_f(1, clamping_type);
|
|
}
|
|
|
|
bc_f(1, segmentation_enable);
|
|
if (current->segmentation_enable)
|
|
CHECK(FUNC(update_segmentation)(ctx, bool_coding_rw, current));
|
|
|
|
bc_f(1, loop_filter_type);
|
|
bc_f(6, loop_filter_level);
|
|
bc_f(3, loop_filter_sharpness);
|
|
|
|
CHECK(FUNC(mode_ref_lf_deltas)(ctx, bool_coding_rw, current));
|
|
|
|
bc_f(2, log2_token_partitions);
|
|
|
|
CHECK(FUNC(quantization_params)(ctx, bool_coding_rw, current));
|
|
|
|
if (current->frame_type != VP8_KEY_FRAME) {
|
|
bc_f(1, refresh_golden_frame);
|
|
bc_f(1, refresh_alternate_frame);
|
|
if (!current->refresh_golden_frame)
|
|
bc_f(2, copy_buffer_to_golden);
|
|
if (!current->refresh_alternate_frame)
|
|
bc_f(2, copy_buffer_to_alternate);
|
|
bc_f(1, ref_frame_sign_bias_golden);
|
|
bc_f(1, ref_frame_sign_bias_alternate);
|
|
}
|
|
bc_f(1, refresh_entropy_probs);
|
|
if (current->frame_type != VP8_KEY_FRAME)
|
|
bc_f(1, refresh_last_frame);
|
|
|
|
CHECK(FUNC(update_token_probs)(ctx, bool_coding_rw, current));
|
|
|
|
bc_f(1, mb_no_skip_coeff);
|
|
if (current->mb_no_skip_coeff)
|
|
bc_f(8, prob_skip_false);
|
|
|
|
if (current->frame_type != VP8_KEY_FRAME) {
|
|
bc_f(8, prob_intra);
|
|
bc_f(8, prob_last);
|
|
bc_f(8, prob_golden);
|
|
|
|
// intra_16x16_prob
|
|
bc_b(intra_16x16_prob_update);
|
|
if (current->intra_16x16_prob_update)
|
|
for (int i = 0; i < 4; i++)
|
|
bc_fs(8, intra_16x16_prob[i], 1, i);
|
|
|
|
// intra_chroma_prob
|
|
bc_b(intra_chrome_prob_update);
|
|
if (current->intra_chrome_prob_update)
|
|
for (int i = 0; i < 3; i++)
|
|
bc_fs(8, intra_chrome_prob[i], 1, i);
|
|
|
|
CHECK(FUNC(update_mv_probs)(ctx, bool_coding_rw, current));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(uncompressed_header)(CodedBitstreamContext *ctx, RWContext *rw,
|
|
VP8RawFrame *current)
|
|
{
|
|
HEADER("Frame");
|
|
|
|
CHECK(FUNC(frame_tag)(ctx, rw, ¤t->header));
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int FUNC(compressed_header)(CodedBitstreamContext *ctx,
|
|
CBSVP8BoolCodingRW *bool_coding_rw,
|
|
VP8RawFrame *current)
|
|
{
|
|
CHECK(FUNC(frame_header)(ctx, bool_coding_rw, ¤t->header));
|
|
|
|
return 0;
|
|
}
|