libavcodec/vp9_raw_reorder_bsf.c - third_party/ffmpeg - Git at Google

 /*
  * 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 "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,
 };
	/*
	* 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 "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,
	};