| /* |
| * 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 |
| */ |
| |
| #include "libavutil/avassert.h" |
| #include "libavutil/intmath.h" |
| #include "libavutil/log.h" |
| #include "libavutil/mem.h" |
| |
| #include "bsf.h" |
| #include "bsf_internal.h" |
| #include "get_bits.h" |
| #include "put_bits.h" |
| |
| #define FRAME_SLOTS 8 |
| |
| typedef struct VP9RawReorderFrame { |
| AVPacket *packet; |
| int needs_output; |
| int needs_display; |
| |
| int64_t pts; |
| int64_t sequence; |
| unsigned int slots; |
| |
| unsigned int profile; |
| |
| unsigned int show_existing_frame; |
| unsigned int frame_to_show; |
| |
| unsigned int frame_type; |
| unsigned int show_frame; |
| unsigned int refresh_frame_flags; |
| } VP9RawReorderFrame; |
| |
| typedef struct VP9RawReorderContext { |
| int64_t sequence; |
| VP9RawReorderFrame *slot[FRAME_SLOTS]; |
| VP9RawReorderFrame *next_frame; |
| } VP9RawReorderContext; |
| |
| static void vp9_raw_reorder_frame_free(VP9RawReorderFrame **frame) |
| { |
| if (*frame) |
| av_packet_free(&(*frame)->packet); |
| av_freep(frame); |
| } |
| |
| static void vp9_raw_reorder_clear_slot(VP9RawReorderContext *ctx, int s) |
| { |
| if (ctx->slot[s]) { |
| ctx->slot[s]->slots &= ~(1 << s); |
| if (ctx->slot[s]->slots == 0) |
| vp9_raw_reorder_frame_free(&ctx->slot[s]); |
| else |
| ctx->slot[s] = NULL; |
| } |
| } |
| |
| static int vp9_raw_reorder_frame_parse(AVBSFContext *bsf, VP9RawReorderFrame *frame) |
| { |
| GetBitContext bc; |
| int err; |
| |
| unsigned int frame_marker; |
| unsigned int profile_low_bit, profile_high_bit, reserved_zero; |
| unsigned int error_resilient_mode; |
| unsigned int frame_sync_code; |
| |
| err = init_get_bits(&bc, frame->packet->data, 8 * frame->packet->size); |
| if (err) |
| return err; |
| |
| frame_marker = get_bits(&bc, 2); |
| if (frame_marker != 2) { |
| av_log(bsf, AV_LOG_ERROR, "Invalid frame marker: %u.\n", |
| frame_marker); |
| return AVERROR_INVALIDDATA; |
| } |
| |
| profile_low_bit = get_bits1(&bc); |
| profile_high_bit = get_bits1(&bc); |
| frame->profile = (profile_high_bit << 1) | profile_low_bit; |
| if (frame->profile == 3) { |
| reserved_zero = get_bits1(&bc); |
| if (reserved_zero != 0) { |
| av_log(bsf, AV_LOG_ERROR, "Profile reserved_zero bit set: " |
| "unsupported profile or invalid bitstream.\n"); |
| return AVERROR_INVALIDDATA; |
| } |
| } |
| |
| frame->show_existing_frame = get_bits1(&bc); |
| if (frame->show_existing_frame) { |
| frame->frame_to_show = get_bits(&bc, 3); |
| return 0; |
| } |
| |
| frame->frame_type = get_bits1(&bc); |
| frame->show_frame = get_bits1(&bc); |
| error_resilient_mode = get_bits1(&bc); |
| |
| if (frame->frame_type == 0) { |
| frame_sync_code = get_bits(&bc, 24); |
| if (frame_sync_code != 0x498342) { |
| av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: %06x.\n", |
| frame_sync_code); |
| return AVERROR_INVALIDDATA; |
| } |
| frame->refresh_frame_flags = 0xff; |
| } else { |
| unsigned int intra_only; |
| |
| if (frame->show_frame == 0) |
| intra_only = get_bits1(&bc); |
| else |
| intra_only = 0; |
| if (error_resilient_mode == 0) { |
| // reset_frame_context |
| skip_bits(&bc, 2); |
| } |
| if (intra_only) { |
| frame_sync_code = get_bits(&bc, 24); |
| if (frame_sync_code != 0x498342) { |
| av_log(bsf, AV_LOG_ERROR, "Invalid frame sync code: " |
| "%06x.\n", frame_sync_code); |
| return AVERROR_INVALIDDATA; |
| } |
| if (frame->profile > 0) { |
| unsigned int color_space; |
| if (frame->profile >= 2) { |
| // ten_or_twelve_bit |
| skip_bits(&bc, 1); |
| } |
| color_space = get_bits(&bc, 3); |
| if (color_space != 7 /* CS_RGB */) { |
| // color_range |
| skip_bits(&bc, 1); |
| if (frame->profile == 1 || frame->profile == 3) { |
| // subsampling |
| skip_bits(&bc, 3); |
| } |
| } else { |
| if (frame->profile == 1 || frame->profile == 3) |
| skip_bits(&bc, 1); |
| } |
| } |
| frame->refresh_frame_flags = get_bits(&bc, 8); |
| } else { |
| frame->refresh_frame_flags = get_bits(&bc, 8); |
| } |
| } |
| |
| return 0; |
| } |
| |
| static int vp9_raw_reorder_make_output(AVBSFContext *bsf, |
| AVPacket *out, |
| VP9RawReorderFrame *last_frame) |
| { |
| VP9RawReorderContext *ctx = bsf->priv_data; |
| VP9RawReorderFrame *next_output = last_frame, |
| *next_display = last_frame, *frame; |
| int s, err; |
| |
| for (s = 0; s < FRAME_SLOTS; s++) { |
| frame = ctx->slot[s]; |
| if (!frame) |
| continue; |
| if (frame->needs_output && (!next_output || |
| frame->sequence < next_output->sequence)) |
| next_output = frame; |
| if (frame->needs_display && (!next_display || |
| frame->pts < next_display->pts)) |
| next_display = frame; |
| } |
| |
| if (!next_output && !next_display) |
| return AVERROR_EOF; |
| |
| if (!next_display || (next_output && |
| next_output->sequence < next_display->sequence)) |
| frame = next_output; |
| else |
| frame = next_display; |
| |
| if (frame->needs_output && frame->needs_display && |
| next_output == next_display) { |
| av_log(bsf, AV_LOG_DEBUG, "Output and display frame " |
| "%"PRId64" (%"PRId64") in order.\n", |
| frame->sequence, frame->pts); |
| |
| av_packet_move_ref(out, frame->packet); |
| |
| frame->needs_output = frame->needs_display = 0; |
| } else if (frame->needs_output) { |
| if (frame->needs_display) { |
| av_log(bsf, AV_LOG_DEBUG, "Output frame %"PRId64" " |
| "(%"PRId64") for later display.\n", |
| frame->sequence, frame->pts); |
| } else { |
| av_log(bsf, AV_LOG_DEBUG, "Output unshown frame " |
| "%"PRId64" (%"PRId64") to keep order.\n", |
| frame->sequence, frame->pts); |
| } |
| |
| av_packet_move_ref(out, frame->packet); |
| out->pts = out->dts; |
| |
| frame->needs_output = 0; |
| } else { |
| PutBitContext pb; |
| |
| av_assert0(!frame->needs_output && frame->needs_display); |
| |
| if (frame->slots == 0) { |
| av_log(bsf, AV_LOG_ERROR, "Attempting to display frame " |
| "which is no longer available?\n"); |
| frame->needs_display = 0; |
| return AVERROR_INVALIDDATA; |
| } |
| |
| s = ff_ctz(frame->slots); |
| av_assert0(s < FRAME_SLOTS); |
| |
| av_log(bsf, AV_LOG_DEBUG, "Display frame %"PRId64" " |
| "(%"PRId64") from slot %d.\n", |
| frame->sequence, frame->pts, s); |
| |
| err = av_new_packet(out, 2); |
| if (err < 0) |
| return err; |
| |
| init_put_bits(&pb, out->data, 2); |
| |
| // frame_marker |
| put_bits(&pb, 2, 2); |
| // profile_low_bit |
| put_bits(&pb, 1, frame->profile & 1); |
| // profile_high_bit |
| put_bits(&pb, 1, (frame->profile >> 1) & 1); |
| if (frame->profile == 3) { |
| // reserved_zero |
| put_bits(&pb, 1, 0); |
| } |
| // show_existing_frame |
| put_bits(&pb, 1, 1); |
| // frame_to_show_map_idx |
| put_bits(&pb, 3, s); |
| |
| while (put_bits_count(&pb) < 16) |
| put_bits(&pb, 1, 0); |
| |
| flush_put_bits(&pb); |
| out->pts = out->dts = frame->pts; |
| |
| frame->needs_display = 0; |
| } |
| |
| return 0; |
| } |
| |
| static int vp9_raw_reorder_filter(AVBSFContext *bsf, AVPacket *out) |
| { |
| VP9RawReorderContext *ctx = bsf->priv_data; |
| VP9RawReorderFrame *frame; |
| AVPacket *in; |
| int err, s; |
| |
| if (ctx->next_frame) { |
| frame = ctx->next_frame; |
| |
| } else { |
| err = ff_bsf_get_packet(bsf, &in); |
| if (err < 0) { |
| if (err == AVERROR_EOF) |
| return vp9_raw_reorder_make_output(bsf, out, NULL); |
| return err; |
| } |
| |
| if ((in->data[in->size - 1] & 0xe0) == 0xc0) { |
| av_log(bsf, AV_LOG_ERROR, "Input in superframes is not " |
| "supported.\n"); |
| av_packet_free(&in); |
| return AVERROR(ENOSYS); |
| } |
| |
| frame = av_mallocz(sizeof(*frame)); |
| if (!frame) { |
| av_packet_free(&in); |
| return AVERROR(ENOMEM); |
| } |
| |
| frame->packet = in; |
| frame->pts = in->pts; |
| frame->sequence = ++ctx->sequence; |
| err = vp9_raw_reorder_frame_parse(bsf, frame); |
| if (err) { |
| av_log(bsf, AV_LOG_ERROR, "Failed to parse input " |
| "frame: %d.\n", err); |
| goto fail; |
| } |
| |
| frame->needs_output = 1; |
| frame->needs_display = frame->pts != AV_NOPTS_VALUE; |
| |
| if (frame->show_existing_frame) |
| av_log(bsf, AV_LOG_DEBUG, "Show frame %"PRId64" " |
| "(%"PRId64"): show %u.\n", frame->sequence, |
| frame->pts, frame->frame_to_show); |
| else |
| av_log(bsf, AV_LOG_DEBUG, "New frame %"PRId64" " |
| "(%"PRId64"): type %u show %u refresh %02x.\n", |
| frame->sequence, frame->pts, frame->frame_type, |
| frame->show_frame, frame->refresh_frame_flags); |
| |
| ctx->next_frame = frame; |
| } |
| |
| for (s = 0; s < FRAME_SLOTS; s++) { |
| if (!(frame->refresh_frame_flags & (1 << s))) |
| continue; |
| if (ctx->slot[s] && ctx->slot[s]->needs_display && |
| ctx->slot[s]->slots == (1 << s)) { |
| // We are overwriting this slot, which is last reference |
| // to the frame previously present in it. In order to be |
| // a valid stream, that frame must already have been |
| // displayed before the pts of the current frame. |
| err = vp9_raw_reorder_make_output(bsf, out, ctx->slot[s]); |
| if (err < 0) { |
| av_log(bsf, AV_LOG_ERROR, "Failed to create " |
| "output overwriting slot %d: %d.\n", |
| s, err); |
| // Clear the slot anyway, so we don't end up |
| // in an infinite loop. |
| vp9_raw_reorder_clear_slot(ctx, s); |
| return AVERROR_INVALIDDATA; |
| } |
| return 0; |
| } |
| vp9_raw_reorder_clear_slot(ctx, s); |
| } |
| |
| for (s = 0; s < FRAME_SLOTS; s++) { |
| if (!(frame->refresh_frame_flags & (1 << s))) |
| continue; |
| ctx->slot[s] = frame; |
| } |
| frame->slots = frame->refresh_frame_flags; |
| |
| if (!frame->refresh_frame_flags) { |
| err = vp9_raw_reorder_make_output(bsf, out, frame); |
| if (err < 0) { |
| av_log(bsf, AV_LOG_ERROR, "Failed to create output " |
| "for transient frame.\n"); |
| ctx->next_frame = NULL; |
| return AVERROR_INVALIDDATA; |
| } |
| if (!frame->needs_display) { |
| vp9_raw_reorder_frame_free(&frame); |
| ctx->next_frame = NULL; |
| } |
| return 0; |
| } |
| |
| ctx->next_frame = NULL; |
| return AVERROR(EAGAIN); |
| |
| fail: |
| vp9_raw_reorder_frame_free(&frame); |
| return err; |
| } |
| |
| static void vp9_raw_reorder_flush(AVBSFContext *bsf) |
| { |
| VP9RawReorderContext *ctx = bsf->priv_data; |
| |
| for (int s = 0; s < FRAME_SLOTS; s++) |
| vp9_raw_reorder_clear_slot(ctx, s); |
| ctx->next_frame = NULL; |
| ctx->sequence = 0; |
| } |
| |
| static void vp9_raw_reorder_close(AVBSFContext *bsf) |
| { |
| VP9RawReorderContext *ctx = bsf->priv_data; |
| int s; |
| |
| for (s = 0; s < FRAME_SLOTS; s++) |
| vp9_raw_reorder_clear_slot(ctx, s); |
| } |
| |
| static const enum AVCodecID vp9_raw_reorder_codec_ids[] = { |
| AV_CODEC_ID_VP9, AV_CODEC_ID_NONE, |
| }; |
| |
| const AVBitStreamFilter ff_vp9_raw_reorder_bsf = { |
| .name = "vp9_raw_reorder", |
| .priv_data_size = sizeof(VP9RawReorderContext), |
| .close = &vp9_raw_reorder_close, |
| .flush = &vp9_raw_reorder_flush, |
| .filter = &vp9_raw_reorder_filter, |
| .codec_ids = vp9_raw_reorder_codec_ids, |
| }; |
