FFmpeg: libavcodec/vmixdec.c Source File

FFmpeg

[フレーム]

libavcodec

vmixdec.c

Go to the documentation of this file.

1 /*

2 * vMix decoder

4 *

5 * This file is part of FFmpeg.

6 *

7 * FFmpeg is free software; you can redistribute it and/or

8 * modify it under the terms of the GNU Lesser General Public

9 * License as published by the Free Software Foundation; either

10 * version 2.1 of the License, or (at your option) any later version.

11 *

12 * FFmpeg is distributed in the hope that it will be useful,

13 * but WITHOUT ANY WARRANTY; without even the implied warranty of

14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU

15 * Lesser General Public License for more details.

16 *

17 * You should have received a copy of the GNU Lesser General Public

18 * License along with FFmpeg; if not, write to the Free Software

19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

20 */

22 #include <stdio.h>

23 #include <stdlib.h>

24 #include <string.h>

26 #include "libavutil/intreadwrite.h"

27 #include "libavutil/mem.h"

28 #include "libavutil/mem_internal.h"

30 #include "avcodec.h"

31 #include "codec_internal.h"

32 #define CACHED_BITSTREAM_READER !ARCH_X86_32

33 #include "golomb.h"

34 #include "get_bits.h"

35 #include "idctdsp.h"

36 #include "thread.h"

38 typedef struct SliceContext {

39 const uint8_t *dc_ptr;

40 const uint8_t *ac_ptr;

41 unsigned dc_size;

42 unsigned ac_size;

43 } SliceContext;

45 typedef struct VMIXContext {

46 int nb_slices;

47 int lshift;

49 int16_t factors[64];

50 uint8_t scan[64];

52 SliceContext *slices;

53 unsigned int slices_size;

55 IDCTDSPContext idsp;

56 } VMIXContext;

58 static const uint8_t quality[] = {

59 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

60 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

61 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,

62 1, 1, 1, 1, 1, 1,64,63,62,61,

63 60,59,58,57,56,55,54,53,52,51,

64 50,49,48,47,46,45,44,43,42,41,

65 40,39,38,37,36,35,34,33,32,31,

66 30,29,28,27,26,25,24,23,22,21,

67 20,19,18,17,16,15,14,13,12,11,

68 10, 9, 8, 7, 6, 5, 4, 3, 2, 1,

69 };

71 static const uint8_t quant[64] = {

72 16, 16, 19, 22, 22, 26, 26, 27,

73 16, 16, 22, 22, 26, 27, 27, 29,

74 19, 22, 26, 26, 27, 29, 29, 35,

75 22, 24, 27, 27, 29, 32, 34, 38,

76 26, 27, 29, 29, 32, 35, 38, 46,

77 27, 29, 34, 34, 35, 40, 46, 56,

78 29, 34, 34, 37, 40, 48, 56, 69,

79 34, 37, 38, 40, 48, 58, 69, 83,

80 };

82 static av_cold int decode_init(AVCodecContext *avctx)

83 {

84 VMIXContext *s = avctx->priv_data;

86 avctx->bits_per_raw_sample = 8;

87 avctx->pix_fmt = AV_PIX_FMT_YUV422P;

89 avctx->coded_width = FFALIGN(avctx->width, 16);

90 avctx->coded_height = FFALIGN(avctx->height, 16);

92 ff_idctdsp_init(&s->idsp, avctx);

93 ff_permute_scantable(s->scan, ff_zigzag_direct,

94 s->idsp.idct_permutation);

95 return 0;

96 }

98 static inline int get_se_golomb_vmix(GetBitContext *gb)

99 {

100 unsigned int buf = get_ue_golomb_long(gb);

101 int sign = (buf & 1) - 1;

102 return ((buf >> 1) ^ (~sign));

103 }

104

105 static int decode_dcac(AVCodecContext *avctx,

106 GetBitContext *dc_gb, GetBitContext *ac_gb,

107 unsigned *dcrun, unsigned *acrun,

108 AVFrame *frame, int width, int by, int plane)

109 {

110 const ptrdiff_t linesize = frame->linesize[plane];

111 uint8_t *dst = frame->data[plane] + by * linesize;

112 unsigned dc_run = *dcrun, ac_run = *acrun;

113 LOCAL_ALIGNED_32(int16_t, block, [64]);

114 VMIXContext *s = avctx->priv_data;

115 const int16_t *factors = s->factors;

116 const uint8_t *scan = s->scan;

117 const int add = plane ? 0 : 1024;

118 int i, dc_v = 0, ac_v = 0, dc = 0;

119 const int lshift = s->lshift;

120

121 for (int y = 0; y < 2; y++) {

122 for (int x = 0; x < width; x += 8) {

123 memset(block, 0, sizeof(*block)*64);

124

125 if (dc_run > 0) {

126 dc_run--;

127 } else {

128 if (get_bits_left(dc_gb) < 1)

129 return AVERROR_INVALIDDATA;

130 dc_v = get_se_golomb_vmix(dc_gb);

131 dc += (unsigned)dc_v;

132 if (!dc_v)

133 dc_run = get_ue_golomb_long(dc_gb);

134 }

135

136 for (int n = 0; n < 64; n++) {

137 if (ac_run > 0) {

138 ac_run--;

139 continue;

140 }

141

142 if (get_bits_left(ac_gb) < 1)

143 return AVERROR_INVALIDDATA;

144 ac_v = get_se_golomb_vmix(ac_gb);

145 i = scan[n];

146 block[i] = ((unsigned)ac_v * factors[i]) >> 4;

147 if (!ac_v)

148 ac_run = get_ue_golomb_long(ac_gb);

149 }

150

151 block[0] = ((unsigned)dc << lshift) + (unsigned)add;

152 s->idsp.idct_put(dst + x, linesize, block);

153 }

154

155 dst += 8 * linesize;

156 }

157

158 *dcrun = dc_run;

159 *acrun = ac_run;

160

161 return 0;

162 }

163

164 static int decode_slice(AVCodecContext *avctx, AVFrame *frame,

165 const uint8_t *dc_src, unsigned dc_slice_size,

166 const uint8_t *ac_src, unsigned ac_slice_size,

167 int by)

168 {

169 unsigned dc_run = 0, ac_run = 0;

170 GetBitContext dc_gb, ac_gb;

171 int ret;

172

173 ret = init_get_bits8(&dc_gb, dc_src, dc_slice_size);

174 if (ret < 0)

175 return ret;

176

177 ret = init_get_bits8(&ac_gb, ac_src, ac_slice_size);

178 if (ret < 0)

179 return ret;

180

181 for (int p = 0; p < 3; p++) {

182 const int rshift = !!p;

183 ret = decode_dcac(avctx, &dc_gb, &ac_gb,

184 &dc_run, &ac_run, frame,

185 frame->width >> rshift, by, p);

186 if (ret < 0)

187 return ret;

188

189 if (get_bits_left(&dc_gb) < 0)

190 return AVERROR_INVALIDDATA;

191 if (get_bits_left(&ac_gb) < 0)

192 return AVERROR_INVALIDDATA;

193

194 align_get_bits(&dc_gb);

195 align_get_bits(&ac_gb);

196 }

197

198 if (get_bits_left(&dc_gb) > 0)

199 return AVERROR_INVALIDDATA;

200 if (get_bits_left(&ac_gb) > 0)

201 return AVERROR_INVALIDDATA;

202

203 return 0;

204 }

205

206 static int decode_slices(AVCodecContext *avctx, void *arg,

207 int n, int thread_nb)

208 {

209 VMIXContext *s = avctx->priv_data;

210 const uint8_t *dc_slice_ptr = s->slices[n].dc_ptr;

211 const uint8_t *ac_slice_ptr = s->slices[n].ac_ptr;

212 unsigned dc_slice_size = s->slices[n].dc_size;

213 unsigned ac_slice_size = s->slices[n].ac_size;

214 AVFrame *frame = arg;

215

216 return decode_slice(avctx, frame, dc_slice_ptr, dc_slice_size,

217 ac_slice_ptr, ac_slice_size, n * 16);

218 }

219

220 static int decode_frame(AVCodecContext *avctx,

221 AVFrame *frame, int *got_frame,

222 AVPacket *avpkt)

223 {

224 VMIXContext *s = avctx->priv_data;

225 unsigned offset, q;

226 int ret;

227

228 if (avpkt->size <= 7)

229 return AVERROR_INVALIDDATA;

230

231 s->lshift = 0;

232 offset = 2 + avpkt->data[0];

233 if (offset == 5)

234 s->lshift = avpkt->data[1];

235 else if (offset != 3)

236 return AVERROR_INVALIDDATA;

237

238 if (s->lshift > 31)

239 return AVERROR_INVALIDDATA;

240

241 q = quality[FFMIN(avpkt->data[offset - 2], FF_ARRAY_ELEMS(quality)-1)];

242 for (int n = 0; n < 64; n++)

243 s->factors[n] = quant[n] * q;

244

245 s->nb_slices = (avctx->height + 15) / 16;

246 av_fast_mallocz(&s->slices, &s->slices_size, s->nb_slices * sizeof(*s->slices));

247 if (!s->slices)

248 return AVERROR(ENOMEM);

249

250 for (int n = 0; n < s->nb_slices; n++) {

251 unsigned slice_size;

252

253 if (offset + 4 > avpkt->size)

254 return AVERROR_INVALIDDATA;

255

256 slice_size = AV_RL32(avpkt->data + offset);

257 if (slice_size > avpkt->size)

258 return AVERROR_INVALIDDATA;

259

260 if (avpkt->size - slice_size - 4LL < offset)

261 return AVERROR_INVALIDDATA;

262

263 s->slices[n].dc_size = slice_size;

264 s->slices[n].dc_ptr = avpkt->data + offset + 4;

265 offset += slice_size + 4;

266 }

267

268 for (int n = 0; n < s->nb_slices; n++) {

269 unsigned slice_size;

270

271 if (offset + 4 > avpkt->size)

272 return AVERROR_INVALIDDATA;

273

274 slice_size = AV_RL32(avpkt->data + offset);

275 if (slice_size > avpkt->size)

276 return AVERROR_INVALIDDATA;

277

278 if (avpkt->size - slice_size - 4LL < offset)

279 return AVERROR_INVALIDDATA;

280

281 s->slices[n].ac_size = slice_size;

282 s->slices[n].ac_ptr = avpkt->data + offset + 4;

283 offset += slice_size + 4;

284 }

285

286 ret = ff_thread_get_buffer(avctx, frame, 0);

287 if (ret < 0)

288 return ret;

289

290 avctx->execute2(avctx, decode_slices, frame, NULL, s->nb_slices);

291

292 *got_frame = 1;

293

294 return avpkt->size;

295 }

296

297 static av_cold int decode_end(AVCodecContext *avctx)

298 {

299 VMIXContext *s = avctx->priv_data;

300 av_freep(&s->slices);

301 return 0;

302 }

303

304 const FFCodec ff_vmix_decoder = {

305 .p.name = "vmix",

306 CODEC_LONG_NAME("vMix Video"),

307 .p.type = AVMEDIA_TYPE_VIDEO,

308 .p.id = AV_CODEC_ID_VMIX,

309 .priv_data_size = sizeof(VMIXContext),

310 .init = decode_init,

311 .close = decode_end,

312 FF_CODEC_DECODE_CB(decode_frame),

313 .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |

314 AV_CODEC_CAP_SLICE_THREADS,

315 };

VMIXContext::factors

int16_t factors[64]

Definition: vmixdec.c:49

decode_slice

static int decode_slice(AVCodecContext *avctx, AVFrame *frame, const uint8_t *dc_src, unsigned dc_slice_size, const uint8_t *ac_src, unsigned ac_slice_size, int by)

Definition: vmixdec.c:164

get_bits_left

static int get_bits_left(GetBitContext *gb)

Definition: get_bits.h:694

AVERROR

Filter the word "frame" indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions

SliceContext::ac_size

unsigned ac_size

Definition: vmixdec.c:42

mem_internal.h

decode_end

static av_cold int decode_end(AVCodecContext *avctx)

Definition: vmixdec.c:297

SliceContext::ac_ptr

const uint8_t * ac_ptr

Definition: vmixdec.c:40

decode_dcac

static int decode_dcac(AVCodecContext *avctx, GetBitContext *dc_gb, GetBitContext *ac_gb, unsigned *dcrun, unsigned *acrun, AVFrame *frame, int width, int by, int plane)

Definition: vmixdec.c:105

AVFrame

This structure describes decoded (raw) audio or video data.

Definition: frame.h:427

VMIXContext::idsp

IDCTDSPContext idsp

Definition: vmixdec.c:55

VMIXContext::slices

SliceContext * slices

Definition: vmixdec.c:52

AVPacket::data

uint8_t * data

Definition: packet.h:588

FFCodec

Definition: codec_internal.h:127

thread.h

ff_idctdsp_init

av_cold void ff_idctdsp_init(IDCTDSPContext *c, AVCodecContext *avctx)

Definition: idctdsp.c:228

golomb.h

exp golomb vlc stuff

ff_permute_scantable

av_cold void ff_permute_scantable(uint8_t dst[64], const uint8_t src[64], const uint8_t permutation[64])

Definition: idctdsp.c:30

static av_cold void close(AVCodecParserContext *s)

Definition: apv_parser.c:136

FFCodec::p

AVCodec p

The public AVCodec.

Definition: codec_internal.h:131

GetBitContext

Definition: get_bits.h:109

AVCodecContext::coded_height

int coded_height

Definition: avcodec.h:607

AV_CODEC_ID_VMIX

@ AV_CODEC_ID_VMIX

Definition: codec_id.h:327

SliceContext::dc_size

unsigned dc_size

Definition: vmixdec.c:41

quant

static const uint8_t quant[64]

Definition: vmixdec.c:71

FF_ARRAY_ELEMS

#define FF_ARRAY_ELEMS(a)

Definition: sinewin_tablegen.c:29

av_cold

#define av_cold

Definition: attributes.h:106

init_get_bits8

static int init_get_bits8(GetBitContext *s, const uint8_t *buffer, int byte_size)

Initialize GetBitContext.

Definition: get_bits.h:544

FF_CODEC_DECODE_CB

#define FF_CODEC_DECODE_CB(func)

Definition: codec_internal.h:347

intreadwrite.h

#define s(width, name)

Definition: cbs_vp9.c:198

decode_frame

static int decode_frame(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *avpkt)

Definition: vmixdec.c:220

ff_thread_get_buffer

int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)

Wrapper around get_buffer() for frame-multithreaded codecs.

Definition: pthread_frame.c:1038

AVCodecContext::bits_per_raw_sample

int bits_per_raw_sample

Bits per sample/pixel of internal libavcodec pixel/sample format.

Definition: avcodec.h:1553

get_se_golomb_vmix

static int get_se_golomb_vmix(GetBitContext *gb)

Definition: vmixdec.c:98

get_bits.h

CODEC_LONG_NAME

#define CODEC_LONG_NAME(str)

Definition: codec_internal.h:332

arg

const char * arg

Definition: jacosubdec.c:67

AV_CODEC_CAP_FRAME_THREADS

#define AV_CODEC_CAP_FRAME_THREADS

Codec supports frame-level multithreading.

Definition: codec.h:95

NULL

#define NULL

Definition: coverity.c:32

LOCAL_ALIGNED_32

#define LOCAL_ALIGNED_32(t, v,...)

Definition: mem_internal.h:132

av_fast_mallocz

void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)

Allocate and clear a buffer, reusing the given one if large enough.

Definition: mem.c:562

quality

static const uint8_t quality[]

Definition: vmixdec.c:58

SliceContext

Definition: mss12.h:70

decode_init

static av_cold int decode_init(AVCodecContext *avctx)

Definition: vmixdec.c:82

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

AV_CODEC_CAP_DR1

#define AV_CODEC_CAP_DR1

Codec uses get_buffer() or get_encode_buffer() for allocating buffers and supports custom allocators.

Definition: codec.h:52

AVPacket::size

int size

Definition: packet.h:589

Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled top and top right vectors is used as motion vector prediction the used motion vector is the sum of the predictor and(mvx_diff, mvy_diff) *mv_scale Intra DC Prediction block[y][x] dc[1]

Definition: snow.txt:400

codec_internal.h

dst

uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst

Definition: dsp.h:87

AV_CODEC_CAP_SLICE_THREADS

#define AV_CODEC_CAP_SLICE_THREADS

Codec supports slice-based (or partition-based) multithreading.

Definition: codec.h:99

offset

it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset

Definition: writing_filters.txt:86

#define i(width, name, range_min, range_max)

Definition: cbs_h2645.c:256

FFMIN

#define FFMIN(a, b)

Definition: macros.h:49

AVCodec::name

const char * name

Name of the codec implementation.

Definition: codec.h:179

VMIXContext::nb_slices

int nb_slices

Definition: vmixdec.c:46

VMIXContext

Definition: vmixdec.c:45

AVCodecContext::height

int height

Definition: avcodec.h:592

AVCodecContext::pix_fmt

enum AVPixelFormat pix_fmt

Pixel format, see AV_PIX_FMT_xxx.

Definition: avcodec.h:631

idctdsp.h

avcodec.h

ff_zigzag_direct

const uint8_t ff_zigzag_direct[64]

Definition: mathtables.c:137

ret

Definition: filter_design.txt:187

frame

these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame

Definition: filter_design.txt:265

VMIXContext::slices_size

unsigned int slices_size

Definition: vmixdec.c:53

align_get_bits

static const uint8_t * align_get_bits(GetBitContext *s)

Definition: get_bits.h:560

IDCTDSPContext

Definition: idctdsp.h:43

AV_RL32

uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32

Definition: bytestream.h:92