FFmpeg: libavfilter/vf_hwmap.c Source File

FFmpeg

[フレーム]

libavfilter

vf_hwmap.c

Go to the documentation of this file.

1 /*

2 * This file is part of FFmpeg.

3 *

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

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

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

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

8 *

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

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

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

12 * Lesser General Public License for more details.

13 *

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

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

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

17 */

19 #include "libavutil/buffer.h"

20 #include "libavutil/hwcontext.h"

21 #include "libavutil/log.h"

22 #include "libavutil/opt.h"

23 #include "libavutil/pixdesc.h"

25 #include "avfilter.h"

26 #include "filters.h"

27 #include "formats.h"

28 #include "video.h"

30 typedef struct HWMapContext {

31 const AVClass *class;

33 AVBufferRef *hwframes_ref;

35 int mode;

36 char *derive_device_type;

37 int reverse;

38 } HWMapContext;

40 static int hwmap_query_formats(const AVFilterContext *avctx,

41 AVFilterFormatsConfig **cfg_in,

42 AVFilterFormatsConfig **cfg_out)

43 {

44 int ret;

46 if ((ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),

47 &cfg_in[0]->formats)) < 0 ||

48 (ret = ff_formats_ref(ff_all_formats(AVMEDIA_TYPE_VIDEO),

49 &cfg_out[0]->formats)) < 0)

50 return ret;

52 return 0;

53 }

55 static int hwmap_config_output(AVFilterLink *outlink)

56 {

57 FilterLink *outl = ff_filter_link(outlink);

58 AVFilterContext *avctx = outlink->src;

59 HWMapContext *ctx = avctx->priv;

60 AVFilterLink *inlink = avctx->inputs[0];

61 FilterLink *inl = ff_filter_link(inlink);

62 AVHWFramesContext *hwfc;

63 AVBufferRef *device;

64 const AVPixFmtDescriptor *desc;

65 int err, device_is_derived;

67 av_log(avctx, AV_LOG_DEBUG, "Configure hwmap %s -> %s.\n",

68 av_get_pix_fmt_name(inlink->format),

69 av_get_pix_fmt_name(outlink->format));

71 av_buffer_unref(&ctx->hwframes_ref);

73 device = avctx->hw_device_ctx;

74 device_is_derived = 0;

76 if (inl->hw_frames_ctx) {

77 hwfc = (AVHWFramesContext*)inl->hw_frames_ctx->data;

79 if (ctx->derive_device_type) {

80 enum AVHWDeviceType type;

82 type = av_hwdevice_find_type_by_name(ctx->derive_device_type);

83 if (type == AV_HWDEVICE_TYPE_NONE) {

84 av_log(avctx, AV_LOG_ERROR, "Invalid device type.\n");

85 err = AVERROR(EINVAL);

86 goto fail;

87 }

89 err = av_hwdevice_ctx_create_derived(&device, type,

90 hwfc->device_ref, 0);

91 if (err < 0) {

92 av_log(avctx, AV_LOG_ERROR, "Failed to created derived "

93 "device context: %d.\n", err);

94 goto fail;

95 }

96 device_is_derived = 1;

97 }

99 desc = av_pix_fmt_desc_get(outlink->format);

100 if (!desc) {

101 err = AVERROR(EINVAL);

102 goto fail;

103 }

104

105 if (inlink->format == hwfc->format &&

106 (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&

107 !ctx->reverse) {

108 // Map between two hardware formats (including the case of

109 // undoing an existing mapping).

110

111 if (!device) {

112 av_log(avctx, AV_LOG_ERROR, "A device reference is "

113 "required to map to a hardware format.\n");

114 err = AVERROR(EINVAL);

115 goto fail;

116 }

117

118 err = av_hwframe_ctx_create_derived(&ctx->hwframes_ref,

119 outlink->format,

120 device,

121 inl->hw_frames_ctx,

122 ctx->mode);

123 if (err < 0) {

124 av_log(avctx, AV_LOG_ERROR, "Failed to create derived "

125 "frames context: %d.\n", err);

126 goto fail;

127 }

128

129 } else if (inlink->format == hwfc->format &&

130 (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) &&

131 ctx->reverse) {

132 // Map between two hardware formats, but do it in reverse.

133 // Make a new hwframe context for the target type, and then

134 // overwrite the input hwframe context with a derived context

135 // mapped from that back to the source type.

136 AVBufferRef *source;

137 AVHWFramesContext *frames;

138

139 ctx->hwframes_ref = av_hwframe_ctx_alloc(device);

140 if (!ctx->hwframes_ref) {

141 err = AVERROR(ENOMEM);

142 goto fail;

143 }

144 frames = (AVHWFramesContext*)ctx->hwframes_ref->data;

145

146 frames->format = outlink->format;

147 frames->sw_format = hwfc->sw_format;

148 frames->width = hwfc->width;

149 frames->height = hwfc->height;

150

151 if (avctx->extra_hw_frames >= 0)

152 frames->initial_pool_size = 2 + avctx->extra_hw_frames;

153

154 err = av_hwframe_ctx_init(ctx->hwframes_ref);

155 if (err < 0) {

156 av_log(avctx, AV_LOG_ERROR, "Failed to initialise "

157 "target frames context: %d.\n", err);

158 goto fail;

159 }

160

161 err = av_hwframe_ctx_create_derived(&source,

162 inlink->format,

163 hwfc->device_ref,

164 ctx->hwframes_ref,

165 ctx->mode);

166 if (err < 0) {

167 av_log(avctx, AV_LOG_ERROR, "Failed to create "

168 "derived source frames context: %d.\n", err);

169 goto fail;

170 }

171

172 // Here is the naughty bit. This overwriting changes what

173 // ff_get_video_buffer() in the previous filter returns -

174 // it will now give a frame allocated here mapped back to

175 // the format it expects. If there were any additional

176 // constraints on the output frames there then this may

177 // break nastily.

178 av_buffer_unref(&inl->hw_frames_ctx);

179 inl->hw_frames_ctx = source;

180

181 } else if ((outlink->format == hwfc->format &&

182 inlink->format == hwfc->sw_format) ||

183 inlink->format == hwfc->format) {

184 // Map from a hardware format to a software format, or

185 // undo an existing such mapping.

186

187 ctx->hwframes_ref = av_buffer_ref(inl->hw_frames_ctx);

188 if (!ctx->hwframes_ref) {

189 err = AVERROR(ENOMEM);

190 goto fail;

191 }

192

193 } else {

194 // Non-matching formats - not supported.

195

196 av_log(avctx, AV_LOG_ERROR, "Unsupported formats for "

197 "hwmap: from %s (%s) to %s.\n",

198 av_get_pix_fmt_name(inlink->format),

199 av_get_pix_fmt_name(hwfc->format),

200 av_get_pix_fmt_name(outlink->format));

201 err = AVERROR(EINVAL);

202 goto fail;

203 }

204 } else if (avctx->hw_device_ctx) {

205 // Map from a software format to a hardware format. This

206 // creates a new hwframe context like hwupload, but then

207 // returns frames mapped from that to the previous link in

208 // order to fill them without an additional copy.

209

210 if (!device) {

211 av_log(avctx, AV_LOG_ERROR, "A device reference is "

212 "required to create new frames with reverse "

213 "mapping.\n");

214 err = AVERROR(EINVAL);

215 goto fail;

216 }

217

218 ctx->reverse = 1;

219

220 ctx->hwframes_ref = av_hwframe_ctx_alloc(device);

221 if (!ctx->hwframes_ref) {

222 err = AVERROR(ENOMEM);

223 goto fail;

224 }

225 hwfc = (AVHWFramesContext*)ctx->hwframes_ref->data;

226

227 hwfc->format = outlink->format;

228 hwfc->sw_format = inlink->format;

229 hwfc->width = inlink->w;

230 hwfc->height = inlink->h;

231

232 if (avctx->extra_hw_frames >= 0)

233 hwfc->initial_pool_size = 2 + avctx->extra_hw_frames;

234

235 err = av_hwframe_ctx_init(ctx->hwframes_ref);

236 if (err < 0) {

237 av_log(avctx, AV_LOG_ERROR, "Failed to create frame "

238 "context for reverse mapping: %d.\n", err);

239 goto fail;

240 }

241

242 } else {

243 av_log(avctx, AV_LOG_ERROR, "Mapping requires a hardware "

244 "context (a device, or frames on input).\n");

245 return AVERROR(EINVAL);

246 }

247

248 outl->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);

249 if (!outl->hw_frames_ctx) {

250 err = AVERROR(ENOMEM);

251 goto fail;

252 }

253

254 outlink->w = inlink->w;

255 outlink->h = inlink->h;

256

257 if (device_is_derived)

258 av_buffer_unref(&device);

259 return 0;

260

261 fail:

262 if (device_is_derived)

263 av_buffer_unref(&device);

264 av_buffer_unref(&ctx->hwframes_ref);

265 return err;

266 }

267

268 static AVFrame *hwmap_get_buffer(AVFilterLink *inlink, int w, int h)

269 {

270 FilterLink *l = ff_filter_link(inlink);

271 AVFilterContext *avctx = inlink->dst;

272 AVFilterLink *outlink = avctx->outputs[0];

273 HWMapContext *ctx = avctx->priv;

274

275 if (ctx->reverse && !l->hw_frames_ctx) {

276 AVFrame *src, *dst;

277 int err;

278

279 src = ff_get_video_buffer(outlink, w, h);

280 if (!src) {

281 av_log(avctx, AV_LOG_ERROR, "Failed to allocate source "

282 "frame for software mapping.\n");

283 return NULL;

284 }

285

286 dst = av_frame_alloc();

287 if (!dst) {

288 av_frame_free(&src);

289 return NULL;

290 }

291

292 err = av_hwframe_map(dst, src, ctx->mode);

293 if (err) {

294 av_log(avctx, AV_LOG_ERROR, "Failed to map frame to "

295 "software: %d.\n", err);

296 av_frame_free(&src);

297 av_frame_free(&dst);

298 return NULL;

299 }

300

301 av_frame_free(&src);

302 return dst;

303 } else {

304 return ff_default_get_video_buffer(inlink, w, h);

305 }

306 }

307

308 static int hwmap_filter_frame(AVFilterLink *link, AVFrame *input)

309 {

310 AVFilterContext *avctx = link->dst;

311 AVFilterLink *outlink = avctx->outputs[0];

312 HWMapContext *ctx = avctx->priv;

313 AVFrame *map = NULL;

314 int err;

315

316 av_log(ctx, AV_LOG_DEBUG, "Filter input: %s, %ux%u (%"PRId64").\n",

317 av_get_pix_fmt_name(input->format),

318 input->width, input->height, input->pts);

319

320 map = av_frame_alloc();

321 if (!map) {

322 err = AVERROR(ENOMEM);

323 goto fail;

324 }

325

326 map->format = outlink->format;

327 map->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);

328 if (!map->hw_frames_ctx) {

329 err = AVERROR(ENOMEM);

330 goto fail;

331 }

332

333 if (ctx->reverse && !input->hw_frames_ctx) {

334 // If we mapped backwards from hardware to software, we need

335 // to attach the hardware frame context to the input frame to

336 // make the mapping visible to av_hwframe_map().

337 input->hw_frames_ctx = av_buffer_ref(ctx->hwframes_ref);

338 if (!input->hw_frames_ctx) {

339 err = AVERROR(ENOMEM);

340 goto fail;

341 }

342 }

343

344 err = av_hwframe_map(map, input, ctx->mode);

345 if (err < 0) {

346 av_log(avctx, AV_LOG_ERROR, "Failed to map frame: %d.\n", err);

347 goto fail;

348 }

349

350 err = av_frame_copy_props(map, input);

351 if (err < 0)

352 goto fail;

353

354 av_frame_free(&input);

355

356 av_log(ctx, AV_LOG_DEBUG, "Filter output: %s, %ux%u (%"PRId64").\n",

357 av_get_pix_fmt_name(map->format),

358 map->width, map->height, map->pts);

359

360 return ff_filter_frame(outlink, map);

361

362 fail:

363 av_frame_free(&input);

364 av_frame_free(&map);

365 return err;

366 }

367

368 static av_cold void hwmap_uninit(AVFilterContext *avctx)

369 {

370 HWMapContext *ctx = avctx->priv;

371

372 av_buffer_unref(&ctx->hwframes_ref);

373 }

374

375 #define OFFSET(x) offsetof(HWMapContext, x)

376 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM)

377 static const AVOption hwmap_options[] = {

378 { "mode", "Frame mapping mode",

379 OFFSET(mode), AV_OPT_TYPE_FLAGS,

380 { .i64 = AV_HWFRAME_MAP_READ | AV_HWFRAME_MAP_WRITE },

381 0, INT_MAX, FLAGS, .unit = "mode" },

382

383 { "read", "Mapping should be readable",

384 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_READ },

385 INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

386 { "write", "Mapping should be writeable",

387 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_WRITE },

388 INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

389 { "overwrite", "Mapping will always overwrite the entire frame",

390 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_OVERWRITE },

391 INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

392 { "direct", "Mapping should not involve any copying",

393 0, AV_OPT_TYPE_CONST, { .i64 = AV_HWFRAME_MAP_DIRECT },

394 INT_MIN, INT_MAX, FLAGS, .unit = "mode" },

395

396 { "derive_device", "Derive a new device of this type",

397 OFFSET(derive_device_type), AV_OPT_TYPE_STRING,

398 { .str = NULL }, 0, 0, FLAGS },

399 { "reverse", "Map in reverse (create and allocate in the sink)",

400 OFFSET(reverse), AV_OPT_TYPE_INT,

401 { .i64 = 0 }, 0, 1, FLAGS },

402

403 { NULL }

404 };

405

406 AVFILTER_DEFINE_CLASS(hwmap);

407

408 static const AVFilterPad hwmap_inputs[] = {

409 {

410 .name = "default",

411 .type = AVMEDIA_TYPE_VIDEO,

412 .get_buffer.video = hwmap_get_buffer,

413 .filter_frame = hwmap_filter_frame,

414 },

415 };

416

417 static const AVFilterPad hwmap_outputs[] = {

418 {

419 .name = "default",

420 .type = AVMEDIA_TYPE_VIDEO,

421 .config_props = hwmap_config_output,

422 },

423 };

424

425 const FFFilter ff_vf_hwmap = {

426 .p.name = "hwmap",

427 .p.description = NULL_IF_CONFIG_SMALL("Map hardware frames"),

428 .p.priv_class = &hwmap_class,

429 .p.flags = AVFILTER_FLAG_HWDEVICE,

430 .uninit = hwmap_uninit,

431 .priv_size = sizeof(HWMapContext),

432 FILTER_INPUTS(hwmap_inputs),

433 FILTER_OUTPUTS(hwmap_outputs),

434 FILTER_QUERY_FUNC2(hwmap_query_formats),

435 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,

436 };

formats

Definition: signature.h:47

ff_get_video_buffer

AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)

Request a picture buffer with a specific set of permissions.

Definition: video.c:117

HWMapContext::derive_device_type

char * derive_device_type

Definition: vf_hwmap.c:36

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

opt.h

hwmap_options

static const AVOption hwmap_options[]

Definition: vf_hwmap.c:377

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

HWMapContext

Definition: vf_hwmap.c:30

av_pix_fmt_desc_get

const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)

Definition: pixdesc.c:3456

AVBufferRef::data

uint8_t * data

The data buffer.

Definition: buffer.h:90

AVHWFramesContext::format

enum AVPixelFormat format

The pixel format identifying the underlying HW surface type.

Definition: hwcontext.h:200

inlink

The exact code depends on how similar the blocks are and how related they are to the and needs to apply these operations to the correct inlink or outlink if there are several Macros are available to factor that when no extra processing is inlink

Definition: filter_design.txt:212

av_frame_free

void av_frame_free(AVFrame **frame)

Free the frame and any dynamically allocated objects in it, e.g.

Definition: frame.c:64

av_hwframe_ctx_init

int av_hwframe_ctx_init(AVBufferRef *ref)

Finalize the context before use.

Definition: hwcontext.c:337

FILTER_INPUTS

#define FILTER_INPUTS(array)

Definition: filters.h:263

test::height

int height

Definition: vc1dsp.c:40

mode

Definition: swscale.c:56

AVFrame

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

Definition: frame.h:427

pixdesc.h

uint8_t w

Definition: llviddspenc.c:38

av_hwframe_ctx_alloc

AVBufferRef * av_hwframe_ctx_alloc(AVBufferRef *device_ref_in)

Allocate an AVHWFramesContext tied to a given device context.

Definition: hwcontext.c:263

AV_HWDEVICE_TYPE_NONE

@ AV_HWDEVICE_TYPE_NONE

Definition: hwcontext.h:28

AVOption

AVOption.

Definition: opt.h:429

av_hwframe_map

int av_hwframe_map(AVFrame *dst, const AVFrame *src, int flags)

Map a hardware frame.

Definition: hwcontext.c:793

HWMapContext::hwframes_ref

AVBufferRef * hwframes_ref

Definition: vf_hwmap.c:33

av_hwdevice_find_type_by_name

enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)

Look up an AVHWDeviceType by name.

Definition: hwcontext.c:110

AVFilterContext::hw_device_ctx

AVBufferRef * hw_device_ctx

For filters which will create hardware frames, sets the device the filter should create them in.

Definition: avfilter.h:356

hwmap_outputs

static const AVFilterPad hwmap_outputs[]

Definition: vf_hwmap.c:417

av_buffer_ref

AVBufferRef * av_buffer_ref(const AVBufferRef *buf)

Create a new reference to an AVBuffer.

Definition: buffer.c:103

AVFilter::name

const char * name

Filter name.

Definition: avfilter.h:220

AVHWFramesContext::width

int width

The allocated dimensions of the frames in this pool.

Definition: hwcontext.h:220

video.h

AVFilterLink

A link between two filters.

Definition: avfilter.h:395

HWMapContext::reverse

int reverse

Definition: vf_hwmap.c:37

FilterLink

Link properties exposed to filter code, but not external callers.

Definition: filters.h:128

formats.h

ff_default_get_video_buffer

AVFrame * ff_default_get_video_buffer(AVFilterLink *link, int w, int h)

Definition: video.c:112

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

fail

#define fail()

Definition: checkasm.h:207

AV_PIX_FMT_FLAG_HWACCEL

#define AV_PIX_FMT_FLAG_HWACCEL

Pixel format is an HW accelerated format.

Definition: pixdesc.h:128

frames

if it could not because there are no more frames

Definition: filter_design.txt:267

AVFilterContext::extra_hw_frames

int extra_hw_frames

Sets the number of extra hardware frames which the filter will allocate on its output links for use i...

Definition: avfilter.h:380

type

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 type

Definition: writing_filters.txt:86

AV_HWFRAME_MAP_OVERWRITE

@ AV_HWFRAME_MAP_OVERWRITE

The mapped frame will be overwritten completely in subsequent operations, so the current frame data n...

Definition: hwcontext.h:525

AV_HWFRAME_MAP_DIRECT

@ AV_HWFRAME_MAP_DIRECT

The mapping must be direct.

Definition: hwcontext.h:531

ff_all_formats

AVFilterFormats * ff_all_formats(enum AVMediaType type)

Return a list of all formats supported by FFmpeg for the given media type.

Definition: formats.c:599

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

av_frame_alloc

AVFrame * av_frame_alloc(void)

Allocate an AVFrame and set its fields to default values.

Definition: frame.c:52

hwmap_uninit

static av_cold void hwmap_uninit(AVFilterContext *avctx)

Definition: vf_hwmap.c:368

AV_LOG_ERROR

#define AV_LOG_ERROR

Something went wrong and cannot losslessly be recovered.

Definition: log.h:210

av_cold

#define av_cold

Definition: attributes.h:106

AVHWFramesContext::height

int height

Definition: hwcontext.h:220

FFFilter

Definition: filters.h:266

ff_formats_ref

int ff_formats_ref(AVFilterFormats *f, AVFilterFormats **ref)

Add *ref as a new reference to formats.

Definition: formats.c:753

AVHWDeviceType

Definition: hwcontext.h:27

filters.h

AV_LOG_DEBUG

#define AV_LOG_DEBUG

Stuff which is only useful for libav* developers.

Definition: log.h:231

ctx

AVFormatContext * ctx

Definition: movenc.c:49

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

link

Definition: filter_design.txt:23

if(ret)

Definition: filter_design.txt:179

AVClass

Describe the class of an AVClass context structure.

Definition: log.h:76

NULL

#define NULL

Definition: coverity.c:32

AVHWFramesContext::sw_format

enum AVPixelFormat sw_format

The pixel format identifying the actual data layout of the hardware frames.

Definition: hwcontext.h:213

av_frame_copy_props

int av_frame_copy_props(AVFrame *dst, const AVFrame *src)

Copy only "metadata" fields from src to dst.

Definition: frame.c:599

av_buffer_unref

void av_buffer_unref(AVBufferRef **buf)

Free a given reference and automatically free the buffer if there are no more references to it.

Definition: buffer.c:139

hwmap_query_formats

static int hwmap_query_formats(const AVFilterContext *avctx, AVFilterFormatsConfig **cfg_in, AVFilterFormatsConfig **cfg_out)

Definition: vf_hwmap.c:40

AVHWFramesContext::device_ref

AVBufferRef * device_ref

A reference to the parent AVHWDeviceContext.

Definition: hwcontext.h:129

AVFilterContext::inputs

AVFilterLink ** inputs

array of pointers to input links

Definition: avfilter.h:282

av_hwframe_ctx_create_derived

int av_hwframe_ctx_create_derived(AVBufferRef **derived_frame_ctx, enum AVPixelFormat format, AVBufferRef *derived_device_ctx, AVBufferRef *source_frame_ctx, int flags)

Create and initialise an AVHWFramesContext as a mapping of another existing AVHWFramesContext on a di...

Definition: hwcontext.c:871

AVFilterFormatsConfig

Lists of formats / etc.

Definition: avfilter.h:121

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

FF_FILTER_FLAG_HWFRAME_AWARE

#define FF_FILTER_FLAG_HWFRAME_AWARE

The filter is aware of hardware frames, and any hardware frame context should not be automatically pr...

Definition: filters.h:207

source

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 source

Definition: filter_design.txt:256

test::width

int width

Definition: vc1dsp.c:39

NULL_IF_CONFIG_SMALL

#define NULL_IF_CONFIG_SMALL(x)

Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.

Definition: internal.h:94

HWMapContext::mode

int mode

Definition: vf_hwmap.c:35

dst

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

Definition: dsp.h:87

AVFILTER_FLAG_HWDEVICE

#define AVFILTER_FLAG_HWDEVICE

The filter can create hardware frames using AVFilterContext.hw_device_ctx.

Definition: avfilter.h:188

AVFilterLink::format

int format

agreed upon media format

Definition: avfilter.h:404

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

buffer.h

AV_HWFRAME_MAP_READ

@ AV_HWFRAME_MAP_READ

The mapping must be readable.

Definition: hwcontext.h:515

input

and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some input

Definition: filter_design.txt:172

FilterLink::hw_frames_ctx

AVBufferRef * hw_frames_ctx

For hwaccel pixel formats, this should be a reference to the AVHWFramesContext describing the frames.

Definition: filters.h:195

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(hwmap)

OFFSET

#define OFFSET(x)

Definition: vf_hwmap.c:375

av_hwdevice_ctx_create_derived

int av_hwdevice_ctx_create_derived(AVBufferRef **dst_ref_ptr, enum AVHWDeviceType type, AVBufferRef *src_ref, int flags)