FFmpeg: libavfilter/vf_scale_vt.c Source File

FFmpeg

[フレーム]

libavfilter

vf_scale_vt.c

Go to the documentation of this file.

1 /*

3 *

4 * This file is part of FFmpeg.

5 *

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

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

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

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

10 *

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

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

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

14 * Lesser General Public License for more details.

15 *

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

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

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

19 */

21 #include <VideoToolbox/VideoToolbox.h>

23 #include "libavutil/hwcontext.h"

24 #include "libavutil/hwcontext_videotoolbox.h"

25 #include "libavutil/opt.h"

26 #include "libavutil/pixdesc.h"

28 #include "filters.h"

29 #include "scale_eval.h"

30 #include "video.h"

32 typedef struct ScaleVtContext {

33 AVClass *class;

35 VTPixelTransferSessionRef transfer;

36 int output_width;

37 int output_height;

38 char *w_expr;

39 char *h_expr;

41 enum AVColorPrimaries colour_primaries;

42 enum AVColorTransferCharacteristic colour_transfer;

43 enum AVColorSpace colour_matrix;

44 char *colour_primaries_string;

45 char *colour_transfer_string;

46 char *colour_matrix_string;

47 } ScaleVtContext;

49 static av_cold int scale_vt_init(AVFilterContext *avctx)

50 {

51 ScaleVtContext *s = avctx->priv;

52 int ret;

53 CFStringRef value;

55 ret = VTPixelTransferSessionCreate(kCFAllocatorDefault, &s->transfer);

56 if (ret != noErr) {

57 av_log(avctx, AV_LOG_ERROR, "transfer session create failed, %d\n", ret);

58 return AVERROR_EXTERNAL;

59 }

61 #define STRING_OPTION(var_name, func_name, default_value) \

62 do { \

63 if (s->var_name##_string) { \

64 int var = av_##func_name##_from_name(s->var_name##_string); \

65 if (var < 0) { \

66 av_log(avctx, AV_LOG_ERROR, "Invalid %s.\n", #var_name); \

67 return AVERROR(EINVAL); \

68 } \

69 s->var_name = var; \

70 } else { \

71 s->var_name = default_value; \

72 } \

73 } while (0)

75 STRING_OPTION(colour_primaries, color_primaries, AVCOL_PRI_UNSPECIFIED);

76 STRING_OPTION(colour_transfer, color_transfer, AVCOL_TRC_UNSPECIFIED);

77 STRING_OPTION(colour_matrix, color_space, AVCOL_SPC_UNSPECIFIED);

79 if (s->colour_primaries != AVCOL_PRI_UNSPECIFIED) {

80 value = av_map_videotoolbox_color_primaries_from_av(s->colour_primaries);

81 if (!value) {

82 av_log(avctx, AV_LOG_ERROR,

83 "Doesn't support converting to colour primaries %s\n",

84 s->colour_primaries_string);

85 return AVERROR(ENOTSUP);

86 }

87 VTSessionSetProperty(s->transfer, kVTPixelTransferPropertyKey_DestinationColorPrimaries, value);

88 }

90 if (s->colour_transfer != AVCOL_TRC_UNSPECIFIED) {

91 value = av_map_videotoolbox_color_trc_from_av(s->colour_transfer);

92 if (!value) {

93 av_log(avctx, AV_LOG_ERROR,

94 "Doesn't support converting to trc %s\n",

95 s->colour_transfer_string);

96 return AVERROR(ENOTSUP);

97 }

98 VTSessionSetProperty(s->transfer, kVTPixelTransferPropertyKey_DestinationTransferFunction, value);

99 }

100

101 if (s->colour_matrix != AVCOL_SPC_UNSPECIFIED) {

102 value = av_map_videotoolbox_color_matrix_from_av(s->colour_matrix);

103 if (!value) {

104 av_log(avctx, AV_LOG_ERROR,

105 "Doesn't support converting to colorspace %s\n",

106 s->colour_matrix_string);

107 return AVERROR(ENOTSUP);

108 }

109 VTSessionSetProperty(s->transfer, kVTPixelTransferPropertyKey_DestinationYCbCrMatrix, value);

110 }

111

112 VTSessionSetProperty(s->transfer, kVTPixelTransferPropertyKey_ScalingMode, kVTScalingMode_CropSourceToCleanAperture);

113

114 return 0;

115 }

116

117 static av_cold void scale_vt_uninit(AVFilterContext *avctx)

118 {

119 ScaleVtContext *s = avctx->priv;

120

121 if (s->transfer) {

122 VTPixelTransferSessionInvalidate(s->transfer);

123 CFRelease(s->transfer);

124 s->transfer = NULL;

125 }

126 }

127

128 static int scale_vt_filter_frame(AVFilterLink *link, AVFrame *in)

129 {

130 int ret;

131 AVFilterContext *ctx = link->dst;

132 ScaleVtContext *s = ctx->priv;

133 AVFilterLink *outlink = ctx->outputs[0];

134 CVPixelBufferRef src;

135 CVPixelBufferRef dst;

136

137 int left;

138 int top;

139 int width;

140 int height;

141 CFNumberRef crop_width_num;

142 CFNumberRef crop_height_num;

143 CFNumberRef crop_offset_left_num;

144 CFNumberRef crop_offset_top_num;

145 const void *clean_aperture_keys[4];

146 const void *source_clean_aperture_values[4];

147 CFDictionaryRef source_clean_aperture;

148

149 AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

150 if (!out) {

151 ret = AVERROR(ENOMEM);

152 goto fail;

153 }

154

155 ret = av_frame_copy_props(out, in);

156 if (ret < 0)

157 goto fail;

158

159 out->crop_left = 0;

160 out->crop_top = 0;

161 out->crop_right = 0;

162 out->crop_bottom = 0;

163 if (out->width != in->width || out->height != in->height) {

164 av_frame_side_data_remove_by_props(&out->side_data, &out->nb_side_data,

165 AV_SIDE_DATA_PROP_SIZE_DEPENDENT);

166 }

167

168 av_reduce(&out->sample_aspect_ratio.num, &out->sample_aspect_ratio.den,

169 (int64_t)in->sample_aspect_ratio.num * outlink->h * link->w,

170 (int64_t)in->sample_aspect_ratio.den * outlink->w * link->h,

171 INT_MAX);

172 if (s->colour_primaries != AVCOL_PRI_UNSPECIFIED)

173 out->color_primaries = s->colour_primaries;

174 if (s->colour_transfer != AVCOL_TRC_UNSPECIFIED)

175 out->color_trc = s->colour_transfer;

176 if (s->colour_matrix != AVCOL_SPC_UNSPECIFIED)

177 out->colorspace = s->colour_matrix;

178

179 width = (in->width - in->crop_right) - in->crop_left;

180 height = (in->height - in->crop_bottom) - in->crop_top;

181 // The crop offsets are relative to the center of the frame.

182 // the crop width and crop height are relative to the center of the crop rect, not top left as normal.

183 left = in->crop_left - in->width / 2 + width / 2;

184 top = in->crop_top - in->height / 2 + height / 2;

185 crop_width_num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &width);

186 crop_height_num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &height);

187 crop_offset_left_num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &left);

188 crop_offset_top_num = CFNumberCreate(kCFAllocatorDefault, kCFNumberIntType, &top);

189

190 clean_aperture_keys[0] = kCVImageBufferCleanApertureWidthKey;

191 clean_aperture_keys[1] = kCVImageBufferCleanApertureHeightKey;

192 clean_aperture_keys[2] = kCVImageBufferCleanApertureHorizontalOffsetKey;

193 clean_aperture_keys[3] = kCVImageBufferCleanApertureVerticalOffsetKey;

194

195 source_clean_aperture_values[0] = crop_width_num;

196 source_clean_aperture_values[1] = crop_height_num;

197 source_clean_aperture_values[2] = crop_offset_left_num;

198 source_clean_aperture_values[3] = crop_offset_top_num;

199

200 source_clean_aperture = CFDictionaryCreate(kCFAllocatorDefault,

201 clean_aperture_keys,

202 source_clean_aperture_values,

203 4,

204 &kCFTypeDictionaryKeyCallBacks,

205 &kCFTypeDictionaryValueCallBacks);

206

207 CFRelease(crop_width_num);

208 CFRelease(crop_height_num);

209 CFRelease(crop_offset_left_num);

210 CFRelease(crop_offset_top_num);

211

212 src = (CVPixelBufferRef)in->data[3];

213 dst = (CVPixelBufferRef)out->data[3];

214 CVBufferSetAttachment(src, kCVImageBufferCleanApertureKey,

215 source_clean_aperture, kCVAttachmentMode_ShouldPropagate);

216 ret = VTPixelTransferSessionTransferImage(s->transfer, src, dst);

217 CFRelease(source_clean_aperture);

218 if (ret != noErr) {

219 av_log(ctx, AV_LOG_ERROR, "transfer image failed, %d\n", ret);

220 ret = AVERROR_EXTERNAL;

221 goto fail;

222 }

223

224 av_frame_free(&in);

225

226 return ff_filter_frame(outlink, out);

227

228 fail:

229 av_frame_free(&in);

230 av_frame_free(&out);

231 return ret;

232 }

233

234 static int scale_vt_config_output(AVFilterLink *outlink)

235 {

236 int err;

237 FilterLink *outl = ff_filter_link(outlink);

238 AVFilterContext *avctx = outlink->src;

239 ScaleVtContext *s = avctx->priv;

240 AVFilterLink *inlink = outlink->src->inputs[0];

241 FilterLink *inl = ff_filter_link(inlink);

242 AVHWFramesContext *hw_frame_ctx_in;

243 AVHWFramesContext *hw_frame_ctx_out;

244

245 err = ff_scale_eval_dimensions(s, s->w_expr, s->h_expr, inlink, outlink,

246 &s->output_width,

247 &s->output_height);

248 if (err < 0)

249 return err;

250

251 ff_scale_adjust_dimensions(inlink, &s->output_width, &s->output_height,

252 SCALE_FORCE_OAR_DISABLE, 1, 1.f);

253

254 outlink->w = s->output_width;

255 outlink->h = s->output_height;

256

257 if (inlink->sample_aspect_ratio.num) {

258 AVRational r = {outlink->h * inlink->w, outlink->w * inlink->h};

259 outlink->sample_aspect_ratio = av_mul_q(r, inlink->sample_aspect_ratio);

260 } else {

261 outlink->sample_aspect_ratio = inlink->sample_aspect_ratio;

262 }

263

264 hw_frame_ctx_in = (AVHWFramesContext *)inl->hw_frames_ctx->data;

265

266 av_buffer_unref(&outl->hw_frames_ctx);

267 outl->hw_frames_ctx = av_hwframe_ctx_alloc(hw_frame_ctx_in->device_ref);

268 hw_frame_ctx_out = (AVHWFramesContext *)outl->hw_frames_ctx->data;

269 hw_frame_ctx_out->format = AV_PIX_FMT_VIDEOTOOLBOX;

270 hw_frame_ctx_out->sw_format = hw_frame_ctx_in->sw_format;

271 hw_frame_ctx_out->width = outlink->w;

272 hw_frame_ctx_out->height = outlink->h;

273 ((AVVTFramesContext *)hw_frame_ctx_out->hwctx)->color_range = ((AVVTFramesContext *)hw_frame_ctx_in->hwctx)->color_range;

274

275 err = ff_filter_init_hw_frames(avctx, outlink, 1);

276 if (err < 0)

277 return err;

278

279 err = av_hwframe_ctx_init(outl->hw_frames_ctx);

280 if (err < 0) {

281 av_log(avctx, AV_LOG_ERROR,

282 "Failed to init videotoolbox frame context, %s\n",

283 av_err2str(err));

284 return err;

285 }

286

287 return 0;

288 }

289

290 #define OFFSET(x) offsetof(ScaleVtContext, x)

291 #define FLAGS (AV_OPT_FLAG_FILTERING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)

292 static const AVOption scale_vt_options[] = {

293 { "w", "Output video width",

294 OFFSET(w_expr), AV_OPT_TYPE_STRING, {.str = "iw"}, .flags = FLAGS },

295 { "h", "Output video height",

296 OFFSET(h_expr), AV_OPT_TYPE_STRING, {.str = "ih"}, .flags = FLAGS },

297 { "color_matrix", "Output colour matrix coefficient set",

298 OFFSET(colour_matrix_string), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },

299 { "color_primaries", "Output colour primaries",

300 OFFSET(colour_primaries_string), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },

301 { "color_transfer", "Output colour transfer characteristics",

302 OFFSET(colour_transfer_string), AV_OPT_TYPE_STRING, { .str = NULL }, .flags = FLAGS },

303 { NULL },

304 };

305

306 AVFILTER_DEFINE_CLASS(scale_vt);

307

308 static const AVFilterPad scale_vt_inputs[] = {

309 {

310 .name = "default",

311 .type = AVMEDIA_TYPE_VIDEO,

312 .filter_frame = &scale_vt_filter_frame,

313 },

314 };

315

316 static const AVFilterPad scale_vt_outputs[] = {

317 {

318 .name = "default",

319 .type = AVMEDIA_TYPE_VIDEO,

320 .config_props = &scale_vt_config_output,

321 },

322 };

323

324 const FFFilter ff_vf_scale_vt = {

325 .p.name = "scale_vt",

326 .p.description = NULL_IF_CONFIG_SMALL("Scale Videotoolbox frames"),

327 .p.priv_class = &scale_vt_class,

328 .p.flags = AVFILTER_FLAG_HWDEVICE,

329 .priv_size = sizeof(ScaleVtContext),

330 .init = scale_vt_init,

331 .uninit = scale_vt_uninit,

332 FILTER_INPUTS(scale_vt_inputs),

333 FILTER_OUTPUTS(scale_vt_outputs),

334 FILTER_SINGLE_PIXFMT(AV_PIX_FMT_VIDEOTOOLBOX),

335 .flags_internal = FF_FILTER_FLAG_HWFRAME_AWARE,

336 };

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

av_map_videotoolbox_color_trc_from_av

CFStringRef av_map_videotoolbox_color_trc_from_av(enum AVColorTransferCharacteristic trc)

Convert an AVColorTransferCharacteristic to a VideoToolbox/CoreVideo color transfer function string.

Definition: hwcontext_videotoolbox.c:490

const char * r

Definition: vf_curves.c:127

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

AVColorTransferCharacteristic

Color Transfer Characteristic.

Definition: pixfmt.h:666

out

FILE * out

Definition: movenc.c:55

av_map_videotoolbox_color_matrix_from_av

CFStringRef av_map_videotoolbox_color_matrix_from_av(enum AVColorSpace space)

Convert an AVColorSpace to a VideoToolbox/CoreVideo color matrix string.

Definition: hwcontext_videotoolbox.c:438

ff_filter_frame

int ff_filter_frame(AVFilterLink *link, AVFrame *frame)

Send a frame of data to the next filter.

Definition: avfilter.c:1067

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

int64_t

long long int64_t

Definition: coverity.c:34

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

AVFrame

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

Definition: frame.h:427

pixdesc.h

AVFrame::width

int width

Definition: frame.h:499

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

AVOption

AVOption.

Definition: opt.h:429

AVCOL_TRC_UNSPECIFIED

@ AVCOL_TRC_UNSPECIFIED

Definition: pixfmt.h:669

ff_scale_eval_dimensions

int ff_scale_eval_dimensions(void *log_ctx, const char *w_expr, const char *h_expr, AVFilterLink *inlink, AVFilterLink *outlink, int *ret_w, int *ret_h)

Parse and evaluate string expressions for width and height.

Definition: scale_eval.c:57

AVColorPrimaries

Chromaticity coordinates of the source primaries.

Definition: pixfmt.h:636

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

AVFrame::data

uint8_t * data[AV_NUM_DATA_POINTERS]

pointer to the picture/channel planes.

Definition: frame.h:448

FilterLink

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

Definition: filters.h:128

scale_vt_filter_frame

static int scale_vt_filter_frame(AVFilterLink *link, AVFrame *in)

Definition: vf_scale_vt.c:128

FLAGS

#define FLAGS

Definition: vf_scale_vt.c:291

AVFilterContext::priv

void * priv

private data for use by the filter

Definition: avfilter.h:289

fail

#define fail()

Definition: checkasm.h:207

scale_vt_init

static av_cold int scale_vt_init(AVFilterContext *avctx)

Definition: vf_scale_vt.c:49

av_reduce

int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)

Reduce a fraction.

Definition: rational.c:35

AVRational::num

int num

Numerator.

Definition: rational.h:59

OFFSET

#define OFFSET(x)

Definition: vf_scale_vt.c:290

scale_vt_config_output

static int scale_vt_config_output(AVFilterLink *outlink)

Definition: vf_scale_vt.c:234

AV_SIDE_DATA_PROP_SIZE_DEPENDENT

@ AV_SIDE_DATA_PROP_SIZE_DEPENDENT

Side data depends on the video dimensions.

Definition: frame.h:309

AVFilterPad

A filter pad used for either input or output.

Definition: filters.h:39

av_map_videotoolbox_color_primaries_from_av

CFStringRef av_map_videotoolbox_color_primaries_from_av(enum AVColorPrimaries pri)

Convert an AVColorPrimaries to a VideoToolbox/CoreVideo color primaries string.

Definition: hwcontext_videotoolbox.c:465

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

SCALE_FORCE_OAR_DISABLE

@ SCALE_FORCE_OAR_DISABLE

Definition: scale_eval.h:25

FFFilter

Definition: filters.h:266

#define s(width, name)

Definition: cbs_vp9.c:198

AVFilterLink::sample_aspect_ratio

AVRational sample_aspect_ratio

agreed upon sample aspect ratio

Definition: avfilter.h:409

filters.h

ctx

AVFormatContext * ctx

Definition: movenc.c:49

AVFrame::crop_right

size_t crop_right

Definition: frame.h:753

color_range

Definition: vf_selectivecolor.c:43

FILTER_OUTPUTS

#define FILTER_OUTPUTS(array)

Definition: filters.h:264

AVCOL_PRI_UNSPECIFIED

@ AVCOL_PRI_UNSPECIFIED

Definition: pixfmt.h:639

AVVTFramesContext

Definition: hwcontext_videotoolbox.h:45

link

Definition: filter_design.txt:23

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

ScaleVtContext::output_width

int output_width

Definition: vf_scale_vt.c:36

AVRational

Rational number (pair of numerator and denominator).

Definition: rational.h:58

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

ScaleVtContext::colour_primaries_string

char * colour_primaries_string

Definition: vf_scale_vt.c:44

ScaleVtContext::w_expr

char * w_expr

Definition: vf_scale_vt.c:38

ff_filter_link

static FilterLink * ff_filter_link(AVFilterLink *link)

Definition: filters.h:198

AVFrame::crop_bottom

size_t crop_bottom

Definition: frame.h:751

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

color_primaries

static const AVColorPrimariesDesc color_primaries[AVCOL_PRI_NB]

Definition: csp.c:76

hwcontext_videotoolbox.h

AVFrame::crop_left

size_t crop_left

Definition: frame.h:752

init

int(* init)(AVBSFContext *ctx)

Definition: dts2pts.c:550

ScaleVtContext::colour_primaries

enum AVColorPrimaries colour_primaries

Definition: vf_scale_vt.c:41

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

ScaleVtContext::h_expr

char * h_expr

Definition: vf_scale_vt.c:39

height

#define height

Definition: dsp.h:89

dst

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

Definition: dsp.h:87

av_err2str

#define av_err2str(errnum)

Convenience macro, the return value should be used only directly in function arguments but never stan...

Definition: error.h:122

AVFILTER_FLAG_HWDEVICE

#define AVFILTER_FLAG_HWDEVICE

The filter can create hardware frames using AVFilterContext.hw_device_ctx.

Definition: avfilter.h:188

ff_vf_scale_vt

const FFFilter ff_vf_scale_vt

Definition: vf_scale_vt.c:324

ScaleVtContext::transfer

VTPixelTransferSessionRef transfer

Definition: vf_scale_vt.c:35

scale_eval.h

AVFilterLink::src

AVFilterContext * src

source filter

Definition: avfilter.h:396

ScaleVtContext::output_height

int output_height

Definition: vf_scale_vt.c:37

AVERROR_EXTERNAL

#define AVERROR_EXTERNAL

Generic error in an external library.

Definition: error.h:59

scale_vt_uninit

static av_cold void scale_vt_uninit(AVFilterContext *avctx)

Definition: vf_scale_vt.c:117

av_frame_side_data_remove_by_props

void av_frame_side_data_remove_by_props(AVFrameSideData ***sd, int *nb_sd, int props)

Remove and free all side data instances that match any of the given side data properties.

Definition: side_data.c:117

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

ScaleVtContext::colour_transfer_string

char * colour_transfer_string

Definition: vf_scale_vt.c:45

AV_PIX_FMT_VIDEOTOOLBOX

@ AV_PIX_FMT_VIDEOTOOLBOX

hardware decoding through Videotoolbox

Definition: pixfmt.h:305

uninit

static void uninit(AVBSFContext *ctx)

Definition: pcm_rechunk.c:68

AVFilterLink::w

int w

agreed upon image width

Definition: avfilter.h:407

AVColorSpace

YUV colorspace type.

Definition: pixfmt.h:700

value

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 default value

Definition: writing_filters.txt:86

AVFilterPad::name

const char * name

Pad name.

Definition: filters.h:45

scale_vt_options

static const AVOption scale_vt_options[]

Definition: vf_scale_vt.c:292

AVCOL_SPC_UNSPECIFIED

@ AVCOL_SPC_UNSPECIFIED

Definition: pixfmt.h:703

scale_vt_outputs

static const AVFilterPad scale_vt_outputs[]

Definition: vf_scale_vt.c:316

ScaleVtContext::colour_transfer

enum AVColorTransferCharacteristic colour_transfer

Definition: vf_scale_vt.c:42

AVHWFramesContext

This struct describes a set or pool of "hardware" frames (i.e.

Definition: hwcontext.h:118

ret

Definition: filter_design.txt:187

AVHWFramesContext::hwctx

void * hwctx

The format-specific data, allocated and freed automatically along with this context.

Definition: hwcontext.h:153

AVFrame::sample_aspect_ratio

AVRational sample_aspect_ratio

Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.

Definition: frame.h:524

left

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 left

Definition: snow.txt:386

AVFILTER_DEFINE_CLASS

AVFILTER_DEFINE_CLASS(scale_vt)

AVFrame::height

int height

Definition: frame.h:499

AVFilterLink::h

int h

agreed upon image height

Definition: avfilter.h:408

AVRational::den

int den