swscale: eliminate redundant SwsInternal accesses

This is a purely cosmetic commit aimed at replacing accesses to SwsInternal.opts by direct access to SwsContext wherever convenient.

Niklas Haas committed 2 years ago

Commit 6a91a161 parent ed5dd677 files · +203 −208Browse files

Unified · Split

7 files

libswscale/options.c +1 −1
libswscale/swscale.c +45 −48
libswscale/utils.c +114 −119
tests/checkasm/sw_gbrp.c +8 −8
tests/checkasm/sw_range_convert.c +8 −8
tests/checkasm/sw_rgb.c +16 −13
tests/checkasm/sw_scale.c +11 −11

libswscale/options.c+1−1

@@ -27,7 +27,7 @@ static const char sws_context_to_name(void ptr) · 26 unmodified lines
27	27	return "swscaler";
28	28	}
29	29
30		−#define OFFSET(x) offsetof(SwsInternal, opts.x)
	30	+#define OFFSET(x) offsetof(SwsContext, x)
31	31	#define DEFAULT 0
32	32	#define VE AV_OPT_FLAG_VIDEO_PARAM \| AV_OPT_FLAG_ENCODING_PARAM
33	33

libswscale/swscale.c+45−48

@@ -895,7 +895,7 @@ static int scale_cascaded(SwsInternal *c, · 894 unmodified lines
895	895	uint8_t * const dstSlice[], const int dstStride[],
896	896	int dstSliceY, int dstSliceH)
897	897	{
898		− const int dstH0 = sws_internal(c->cascaded_context[0])->opts.dst_h;
	898	+ const int dstH0 = c->cascaded_context[0]->dst_h;
899	899	int ret = scale_internal(c->cascaded_context[0],
900	900	srcSlice, srcStride, srcSliceY, srcSliceH,
901	901	c->cascaded_tmp[0], c->cascaded_tmpStride[0],
@@ -915,13 +915,13 @@ static int scale_internal(SwsContext *sws, · 13 unmodified lines
915	915	int dstSliceY, int dstSliceH)
916	916	{
917	917	SwsInternal *c = sws_internal(sws);
918		− const int scale_dst = dstSliceY > 0 \|\| dstSliceH < c->opts.dst_h;
	918	+ const int scale_dst = dstSliceY > 0 \|\| dstSliceH < sws->dst_h;
919	919	const int frame_start = scale_dst \|\| !c->sliceDir;
920	920	int i, ret;
921	921	const uint8_t *src2[4];
922	922	uint8_t *dst2[4];
923		− int macro_height_src = isBayer(c->opts.src_format) ? 2 : (1 << c->chrSrcVSubSample);
924		− int macro_height_dst = isBayer(c->opts.dst_format) ? 2 : (1 << c->chrDstVSubSample);
	923	+ int macro_height_src = isBayer(sws->src_format) ? 2 : (1 << c->chrSrcVSubSample);
	924	+ int macro_height_dst = isBayer(sws->dst_format) ? 2 : (1 << c->chrDstVSubSample);
925	925	// copy strides, so they can safely be modified
926	926	int srcStride2[4];
927	927	int dstStride2[4];
@@ -933,25 +933,25 @@ static int scale_internal(SwsContext *sws, · 5 unmodified lines
933	933	}
934	934
935	935	if ((srcSliceY & (macro_height_src - 1)) \|\|
936		− ((srcSliceH & (macro_height_src - 1)) && srcSliceY + srcSliceH != c->opts.src_h) \|\|
937		− srcSliceY + srcSliceH > c->opts.src_h \|\|
938		− (isBayer(c->opts.src_format) && srcSliceH <= 1)) {
	936	+ ((srcSliceH & (macro_height_src - 1)) && srcSliceY + srcSliceH != sws->src_h) \|\|
	937	+ srcSliceY + srcSliceH > sws->src_h \|\|
	938	+ (isBayer(sws->src_format) && srcSliceH <= 1)) {
939	939	av_log(c, AV_LOG_ERROR, "Slice parameters %d, %d are invalid\n", srcSliceY, srcSliceH);
940	940	return AVERROR(EINVAL);
941	941	}
942	942
943	943	if ((dstSliceY & (macro_height_dst - 1)) \|\|
944		− ((dstSliceH & (macro_height_dst - 1)) && dstSliceY + dstSliceH != c->opts.dst_h) \|\|
945		− dstSliceY + dstSliceH > c->opts.dst_h) {
	944	+ ((dstSliceH & (macro_height_dst - 1)) && dstSliceY + dstSliceH != sws->dst_h) \|\|
	945	+ dstSliceY + dstSliceH > sws->dst_h) {
946	946	av_log(c, AV_LOG_ERROR, "Slice parameters %d, %d are invalid\n", dstSliceY, dstSliceH);
947	947	return AVERROR(EINVAL);
948	948	}
949	949
950		− if (!check_image_pointers(srcSlice, c->opts.src_format, srcStride)) {
	950	+ if (!check_image_pointers(srcSlice, sws->src_format, srcStride)) {
951	951	av_log(c, AV_LOG_ERROR, "bad src image pointers\n");
952	952	return AVERROR(EINVAL);
953	953	}
954		− if (!check_image_pointers((const uint8_t* const*)dstSlice, c->opts.dst_format, dstStride)) {
	954	+ if (!check_image_pointers((const uint8_t* const*)dstSlice, sws->dst_format, dstStride)) {
955	955	av_log(c, AV_LOG_ERROR, "bad dst image pointers\n");
956	956	return AVERROR(EINVAL);
957	957	}
@@ -960,22 +960,19 @@ static int scale_internal(SwsContext *sws, · 2 unmodified lines
960	960	if (srcSliceH == 0)
961	961	return 0;
962	962
963		− if (c->opts.gamma_flag && c->cascaded_context[0])
	963	+ if (sws->gamma_flag && c->cascaded_context[0])
964	964	return scale_gamma(c, srcSlice, srcStride, srcSliceY, srcSliceH,
965	965	dstSlice, dstStride, dstSliceY, dstSliceH);
966	966
967		− if (c->cascaded_context[0] && srcSliceY == 0 &&
968		− srcSliceH == sws_internal(c->cascaded_context[0])->opts.src_h)
969		− {
	967	+ if (c->cascaded_context[0] && srcSliceY == 0 && srcSliceH == c->cascaded_context[0]->src_h)
970	968	return scale_cascaded(c, srcSlice, srcStride, srcSliceY, srcSliceH,
971	969	dstSlice, dstStride, dstSliceY, dstSliceH);
972		− }
973	970
974		− if (!srcSliceY && (c->opts.flags & SWS_BITEXACT) && c->opts.dither == SWS_DITHER_ED && c->dither_error[0])
	971	+ if (!srcSliceY && (sws->flags & SWS_BITEXACT) && sws->dither == SWS_DITHER_ED && c->dither_error[0])
975	972	for (i = 0; i < 4; i++)
976		− memset(c->dither_error[i], 0, sizeof(c->dither_error[0][0]) * (c->opts.dst_w+2));
	973	+ memset(c->dither_error[i], 0, sizeof(c->dither_error[0][0]) * (sws->dst_w+2));
977	974
978		− if (usePal(c->opts.src_format))
	975	+ if (usePal(sws->src_format))
979	976	ff_update_palette(c, (const uint32_t *)srcSlice[1]);
980	977
981	978	memcpy(src2, srcSlice, sizeof(src2));
@@ -984,7 +981,7 @@ static int scale_internal(SwsContext *sws, · 2 unmodified lines
984	981	memcpy(dstStride2, dstStride, sizeof(dstStride2));
985	982
986	983	if (frame_start && !scale_dst) {
987		− if (srcSliceY != 0 && srcSliceY + srcSliceH != c->opts.src_h) {
	984	+ if (srcSliceY != 0 && srcSliceY + srcSliceH != sws->src_h) {
988	985	av_log(c, AV_LOG_ERROR, "Slices start in the middle!\n");
989	986	return AVERROR(EINVAL);
990	987	}
@@ -993,7 +990,7 @@ static int scale_internal(SwsContext *sws, · 2 unmodified lines
993	990	} else if (scale_dst)
994	991	c->sliceDir = 1;
995	992
996		− if (c->src0Alpha && !c->dst0Alpha && isALPHA(c->opts.dst_format)) {
	993	+ if (c->src0Alpha && !c->dst0Alpha && isALPHA(sws->dst_format)) {
997	994	uint8_t *base;
998	995	int x,y;
999	996
@@ -1005,15 +1002,15 @@ static int scale_internal(SwsContext *sws, · 5 unmodified lines
1005	1002	base = srcStride[0] < 0 ? c->rgb0_scratch - srcStride[0] * (srcSliceH-1) :
1006	1003	c->rgb0_scratch;
1007	1004	for (y=0; y<srcSliceH; y++){
1008		− memcpy(base + srcStride[0]y, src2[0] + srcStride[0]y, 4*c->opts.src_w);
1009		− for (x=c->src0Alpha-1; x<4*c->opts.src_w; x+=4) {
	1005	+ memcpy(base + srcStride[0]y, src2[0] + srcStride[0]y, 4*sws->src_w);
	1006	+ for (x=c->src0Alpha-1; x<4*sws->src_w; x+=4) {
1010	1007	base[ srcStride[0]*y + x] = 0xFF;
1011	1008	}
1012	1009	}
1013	1010	src2[0] = base;
1014	1011	}
1015	1012
1016		− if (c->srcXYZ && !(c->dstXYZ && c->opts.src_w==c->opts.dst_w && c->opts.src_h==c->opts.dst_h)) {
	1013	+ if (c->srcXYZ && !(c->dstXYZ && sws->src_w==sws->dst_w && sws->src_h==sws->dst_h)) {
1017	1014	uint8_t *base;
1018	1015
1019	1016	av_fast_malloc(&c->xyz_scratch, &c->xyz_scratch_allocated,
@@ -1024,7 +1021,7 @@ static int scale_internal(SwsContext *sws, · 4 unmodified lines
1024	1021	base = srcStride[0] < 0 ? c->xyz_scratch - srcStride[0] * (srcSliceH-1) :
1025	1022	c->xyz_scratch;
1026	1023
1027		− ff_xyz12Torgb48(c, base, srcStride[0], src2[0], srcStride[0], c->opts.src_w, srcSliceH);
	1024	+ ff_xyz12Torgb48(c, base, srcStride[0], src2[0], srcStride[0], sws->src_w, srcSliceH);
1028	1025	src2[0] = base;
1029	1026	}
1030	1027
@@ -1036,19 +1033,19 @@ static int scale_internal(SwsContext *sws, · 5 unmodified lines
1036	1033	}
1037	1034
1038	1035	src2[0] += (srcSliceH - 1) * srcStride[0];
1039		− if (!usePal(c->opts.src_format))
	1036	+ if (!usePal(sws->src_format))
1040	1037	src2[1] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[1];
1041	1038	src2[2] += ((srcSliceH >> c->chrSrcVSubSample) - 1) * srcStride[2];
1042	1039	src2[3] += (srcSliceH - 1) * srcStride[3];
1043		− dst2[0] += ( c->opts.dst_h - 1) * dstStride[0];
1044		− dst2[1] += ((c->opts.dst_h >> c->chrDstVSubSample) - 1) * dstStride[1];
1045		− dst2[2] += ((c->opts.dst_h >> c->chrDstVSubSample) - 1) * dstStride[2];
1046		− dst2[3] += ( c->opts.dst_h - 1) * dstStride[3];
	1040	+ dst2[0] += ( sws->dst_h - 1) * dstStride[0];
	1041	+ dst2[1] += ((sws->dst_h >> c->chrDstVSubSample) - 1) * dstStride[1];
	1042	+ dst2[2] += ((sws->dst_h >> c->chrDstVSubSample) - 1) * dstStride[2];
	1043	+ dst2[3] += ( sws->dst_h - 1) * dstStride[3];
1047	1044
1048		− srcSliceY_internal = c->opts.src_h-srcSliceY-srcSliceH;
	1045	+ srcSliceY_internal = sws->src_h-srcSliceY-srcSliceH;
1049	1046	}
1050		− reset_ptr(src2, c->opts.src_format);
1051		− reset_ptr((void*)dst2, c->opts.dst_format);
	1047	+ reset_ptr(src2, sws->src_format);
	1048	+ reset_ptr((void*)dst2, sws->dst_format);
1052	1049
1053	1050	if (c->convert_unscaled) {
1054	1051	int offset = srcSliceY_internal;
@@ -1058,13 +1055,13 @@ static int scale_internal(SwsContext *sws, · 3 unmodified lines
1058	1055	if (scale_dst) {
1059	1056	av_assert0(offset == 0);
1060	1057	for (i = 0; i < 4 && src2[i]; i++) {
1061		− if (!src2[i] \|\| (i > 0 && usePal(c->opts.src_format)))
	1058	+ if (!src2[i] \|\| (i > 0 && usePal(sws->src_format)))
1062	1059	break;
1063	1060	src2[i] += (dstSliceY >> ((i == 1 \|\| i == 2) ? c->chrSrcVSubSample : 0)) * srcStride2[i];
1064	1061	}
1065	1062
1066	1063	for (i = 0; i < 4 && dst2[i]; i++) {
1067		− if (!dst2[i] \|\| (i > 0 && usePal(c->opts.dst_format)))
	1064	+ if (!dst2[i] \|\| (i > 0 && usePal(sws->dst_format)))
1068	1065	break;
1069	1066	dst2[i] -= (dstSliceY >> ((i == 1 \|\| i == 2) ? c->chrDstVSubSample : 0)) * dstStride2[i];
1070	1067	}
@@ -1081,7 +1078,7 @@ static int scale_internal(SwsContext *sws, · 10 unmodified lines
1081	1078	dst2, dstStride2, dstSliceY, dstSliceH);
1082	1079	}
1083	1080
1084		− if (c->dstXYZ && !(c->srcXYZ && c->opts.src_w==c->opts.dst_w && c->opts.src_h==c->opts.dst_h)) {
	1081	+ if (c->dstXYZ && !(c->srcXYZ && sws->src_w==sws->dst_w && sws->src_h==sws->dst_h)) {
1085	1082	uint8_t *dst;
1086	1083
1087	1084	if (scale_dst) {
@@ -1091,16 +1088,16 @@ static int scale_internal(SwsContext *sws, · 3 unmodified lines
1091	1088
1092	1089	av_assert0(dstY >= ret);
1093	1090	av_assert0(ret >= 0);
1094		− av_assert0(c->opts.dst_h >= dstY);
	1091	+ av_assert0(sws->dst_h >= dstY);
1095	1092	dst = dst2[0] + (dstY - ret) * dstStride2[0];
1096	1093	}
1097	1094
1098	1095	/* replace on the same data */
1099		− ff_rgb48Toxyz12(c, dst, dstStride2[0], dst, dstStride2[0], c->opts.dst_w, ret);
	1096	+ ff_rgb48Toxyz12(c, dst, dstStride2[0], dst, dstStride2[0], sws->dst_w, ret);
1100	1097	}
1101	1098
1102	1099	/* reset slice direction at end of frame */
1103		− if ((srcSliceY_internal + srcSliceH == c->opts.src_h) \|\| scale_dst)
	1100	+ if ((srcSliceY_internal + srcSliceH == sws->src_h) \|\| scale_dst)
1104	1101	c->sliceDir = 0;
1105	1102
1106	1103	return ret;
@@ -1124,9 +1121,9 @@ int sws_frame_start(SwsContext sws, AVFrame dst, const AVFrame *src) · 17 unmodified lines
1124	1121	return ret;
1125	1122
1126	1123	if (!dst->buf[0]) {
1127		− dst->width = c->opts.dst_w;
1128		− dst->height = c->opts.dst_h;
1129		− dst->format = c->opts.dst_format;
	1124	+ dst->width = sws->dst_w;
	1125	+ dst->height = sws->dst_h;
	1126	+ dst->format = sws->dst_format;
1130	1127
1131	1128	ret = av_frame_get_buffer(dst, 0);
1132	1129	if (ret < 0)
@@ -1177,10 +1174,10 @@ int sws_receive_slice(SwsContext *sws, unsigned int slice_start, · 44 unmodified lines
1177	1174	/* wait until complete input has been received */
1178	1175	if (!(c->src_ranges.nb_ranges == 1 &&
1179	1176	c->src_ranges.ranges[0].start == 0 &&
1180		− c->src_ranges.ranges[0].len == c->opts.src_h))
	1177	+ c->src_ranges.ranges[0].len == sws->src_h))
1181	1178	return AVERROR(EAGAIN);
1182	1179
1183		− if ((slice_start > 0 \|\| slice_height < c->opts.dst_h) &&
	1180	+ if ((slice_start > 0 \|\| slice_height < sws->dst_h) &&
1184	1181	(slice_start % align \|\| slice_height % align)) {
1185	1182	av_log(c, AV_LOG_ERROR,
1186	1183	"Incorrectly aligned output: %u/%u not multiples of %u\n",
@@ -1192,7 +1189,7 @@ int sws_receive_slice(SwsContext *sws, unsigned int slice_start, · 5 unmodified lines
1192	1189	int nb_jobs = c->nb_slice_ctx;
1193	1190	int ret = 0;
1194	1191
1195		− if (sws_internal(c->slice_ctx[0])->opts.dither == SWS_DITHER_ED)
	1192	+ if (c->slice_ctx[0]->dither == SWS_DITHER_ED)
1196	1193	nb_jobs = 1;
1197	1194
1198	1195	c->dst_slice_start = slice_start;
@@ -1218,7 +1215,7 @@ int sws_receive_slice(SwsContext *sws, unsigned int slice_start, · 19 unmodified lines
1218	1215	}
1219	1216
1220	1217	return scale_internal(sws, (const uint8_t * const *)c->frame_src->data,
1221		− c->frame_src->linesize, 0, c->opts.src_h,
	1218	+ c->frame_src->linesize, 0, sws->src_h,
1222	1219	dst, c->frame_dst->linesize, slice_start, slice_height);
1223	1220	}
1224	1221
@@ -1256,7 +1253,7 @@ int attribute_align_arg sws_scale(SwsContext *sws, · 31 unmodified lines
1256	1253	}
1257	1254
1258	1255	return scale_internal(sws, srcSlice, srcStride, srcSliceY, srcSliceH,
1259		− dst, dstStride, 0, c->opts.dst_h);
	1256	+ dst, dstStride, 0, sws->dst_h);
1260	1257	}
1261	1258
1262	1259	void ff_sws_slice_worker(void *priv, int jobnr, int threadnr,
@@ -1284,7 +1281,7 @@ void ff_sws_slice_worker(void *priv, int jobnr, int threadnr, · 21 unmodified lines
1284	1281	}
1285	1282
1286	1283	err = scale_internal(sws, (const uint8_t * const *)parent->frame_src->data,
1287		− parent->frame_src->linesize, 0, c->opts.src_h,
	1284	+ parent->frame_src->linesize, 0, sws->src_h,
1288	1285	dst, parent->frame_dst->linesize,
1289	1286	parent->dst_slice_start + slice_start, slice_end - slice_start);
1290	1287	}

libswscale/utils.c+114−119

@@ -1026,12 +1026,13 @@ static int handle_xyz(enum AVPixelFormat *format) · 1025 unmodified lines
1026	1026	}
1027	1027	}
1028	1028
1029		−static void handle_formats(SwsInternal *c)
	1029	+static void handle_formats(SwsContext *sws)
1030	1030	{
1031		− c->src0Alpha \|= handle_0alpha(&c->opts.src_format);
1032		− c->dst0Alpha \|= handle_0alpha(&c->opts.dst_format);
1033		− c->srcXYZ \|= handle_xyz(&c->opts.src_format);
1034		− c->dstXYZ \|= handle_xyz(&c->opts.dst_format);
	1031	+ SwsInternal *c = sws_internal(sws);
	1032	+ c->src0Alpha \|= handle_0alpha(&sws->src_format);
	1033	+ c->dst0Alpha \|= handle_0alpha(&sws->dst_format);
	1034	+ c->srcXYZ \|= handle_xyz(&sws->src_format);
	1035	+ c->dstXYZ \|= handle_xyz(&sws->dst_format);
1035	1036	if (c->srcXYZ \|\| c->dstXYZ)
1036	1037	fill_xyztables(c);
1037	1038	}
@@ -1063,17 +1064,17 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 25 unmodified lines
1063	1064	return parent_ret;
1064	1065	}
1065	1066
1066		− handle_formats(c);
1067		− desc_dst = av_pix_fmt_desc_get(c->opts.dst_format);
1068		− desc_src = av_pix_fmt_desc_get(c->opts.src_format);
	1067	+ handle_formats(sws);
	1068	+ desc_dst = av_pix_fmt_desc_get(sws->dst_format);
	1069	+ desc_src = av_pix_fmt_desc_get(sws->src_format);
1069	1070
1070		− if(range_override_needed(c->opts.dst_format))
	1071	+ if(range_override_needed(sws->dst_format))
1071	1072	dstRange = 0;
1072		− if(range_override_needed(c->opts.src_format))
	1073	+ if(range_override_needed(sws->src_format))
1073	1074	srcRange = 0;
1074	1075
1075		− if (c->opts.src_range != srcRange \|\|
1076		− c->opts.dst_range != dstRange \|\|
	1076	+ if (sws->src_range != srcRange \|\|
	1077	+ sws->dst_range != dstRange \|\|
1077	1078	c->brightness != brightness \|\|
1078	1079	c->contrast != contrast \|\|
1079	1080	c->saturation != saturation \|\|
@@ -1090,8 +1091,8 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 10 unmodified lines
1090	1091	c->brightness = brightness;
1091	1092	c->contrast = contrast;
1092	1093	c->saturation = saturation;
1093		− c->opts.src_range = srcRange;
1094		− c->opts.dst_range = dstRange;
	1094	+ sws->src_range = srcRange;
	1095	+ sws->dst_range = dstRange;
1095	1096
1096	1097	if (need_reinit)
1097	1098	ff_sws_init_range_convert(c);
@@ -1105,27 +1106,27 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 7 unmodified lines
1105	1106	if (!need_reinit)
1106	1107	return 0;
1107	1108
1108		− if ((isYUV(c->opts.dst_format) \|\| isGray(c->opts.dst_format)) && (isYUV(c->opts.src_format) \|\| isGray(c->opts.src_format))) {
	1109	+ if ((isYUV(sws->dst_format) \|\| isGray(sws->dst_format)) && (isYUV(sws->src_format) \|\| isGray(sws->src_format))) {
1109	1110	if (!c->cascaded_context[0] &&
1110	1111	memcmp(c->dstColorspaceTable, c->srcColorspaceTable, sizeof(int) * 4) &&
1111		− c->opts.src_w && c->opts.src_h && c->opts.dst_w && c->opts.dst_h) {
	1112	+ sws->src_w && sws->src_h && sws->dst_w && sws->dst_h) {
1112	1113	enum AVPixelFormat tmp_format;
1113	1114	int tmp_width, tmp_height;
1114		− int srcW = c->opts.src_w;
1115		− int srcH = c->opts.src_h;
1116		− int dstW = c->opts.dst_w;
1117		− int dstH = c->opts.dst_h;
	1115	+ int srcW = sws->src_w;
	1116	+ int srcH = sws->src_h;
	1117	+ int dstW = sws->dst_w;
	1118	+ int dstH = sws->dst_h;
1118	1119	int ret;
1119	1120	av_log(c, AV_LOG_VERBOSE, "YUV color matrix differs for YUV->YUV, using intermediate RGB to convert\n");
1120	1121
1121		− if (isNBPS(c->opts.dst_format) \|\| is16BPS(c->opts.dst_format)) {
1122		− if (isALPHA(c->opts.src_format) && isALPHA(c->opts.dst_format)) {
	1122	+ if (isNBPS(sws->dst_format) \|\| is16BPS(sws->dst_format)) {
	1123	+ if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) {
1123	1124	tmp_format = AV_PIX_FMT_BGRA64;
1124	1125	} else {
1125	1126	tmp_format = AV_PIX_FMT_BGR48;
1126	1127	}
1127	1128	} else {
1128		− if (isALPHA(c->opts.src_format) && isALPHA(c->opts.dst_format)) {
	1129	+ if (isALPHA(sws->src_format) && isALPHA(sws->dst_format)) {
1129	1130	tmp_format = AV_PIX_FMT_BGRA;
1130	1131	} else {
1131	1132	tmp_format = AV_PIX_FMT_BGR24;
@@ -1145,14 +1146,13 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 13 unmodified lines
1145	1146	if (ret < 0)
1146	1147	return ret;
1147	1148
1148		− c->cascaded_context[0] = alloc_set_opts(srcW, srcH, c->opts.src_format,
	1149	+ c->cascaded_context[0] = alloc_set_opts(srcW, srcH, sws->src_format,
1149	1150	tmp_width, tmp_height, tmp_format,
1150		− c->opts.flags,
1151		− c->opts.scaler_params);
	1151	+ sws->flags, sws->scaler_params);
1152	1152	if (!c->cascaded_context[0])
1153	1153	return -1;
1154	1154
1155		− sws_internal(c->cascaded_context[0])->opts.alpha_blend = c->opts.alpha_blend;
	1155	+ c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
1156	1156	ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1157	1157	if (ret < 0)
1158	1158	return ret;
@@ -1162,13 +1162,12 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 3 unmodified lines
1162	1162	brightness, contrast, saturation);
1163	1163
1164	1164	c->cascaded_context[1] = alloc_set_opts(tmp_width, tmp_height, tmp_format,
1165		− dstW, dstH, c->opts.dst_format,
1166		− c->opts.flags,
1167		− c->opts.scaler_params);
	1165	+ dstW, dstH, sws->dst_format,
	1166	+ sws->flags, sws->scaler_params);
1168	1167	if (!c->cascaded_context[1])
1169	1168	return -1;
1170		− sws_internal(c->cascaded_context[1])->opts.src_range = srcRange;
1171		− sws_internal(c->cascaded_context[1])->opts.dst_range = dstRange;
	1169	+ c->cascaded_context[1]->src_range = srcRange;
	1170	+ c->cascaded_context[1]->dst_range = dstRange;
1172	1171	ret = sws_init_context(c->cascaded_context[1], NULL , NULL);
1173	1172	if (ret < 0)
1174	1173	return ret;
@@ -1183,7 +1182,7 @@ int sws_setColorspaceDetails(SwsContext *sws, const int inv_table[4], · 8 unmodified lines
1183	1182	return 0;
1184	1183	}
1185	1184
1186		− if (!isYUV(c->opts.dst_format) && !isGray(c->opts.dst_format)) {
	1185	+ if (!isYUV(sws->dst_format) && !isGray(sws->dst_format)) {
1187	1186	ff_yuv2rgb_c_init_tables(c, inv_table, srcRange, brightness,
1188	1187	contrast, saturation);
1189	1188	// FIXME factorize
@@ -1215,8 +1214,8 @@ int sws_getColorspaceDetails(SwsContext sws, int *inv_table, · 25 unmodified lines
1215	1214
1216	1215	*inv_table = c->srcColorspaceTable;
1217	1216	*table = c->dstColorspaceTable;
1218		− *srcRange = range_override_needed(c->opts.src_format) ? 1 : c->opts.src_range;
1219		− *dstRange = range_override_needed(c->opts.dst_format) ? 1 : c->opts.dst_range;
	1217	+ *srcRange = range_override_needed(sws->src_format) ? 1 : sws->src_range;
	1218	+ *dstRange = range_override_needed(sws->dst_format) ? 1 : sws->dst_range;
1220	1219	*brightness = c->brightness;
1221	1220	*contrast = c->contrast;
1222	1221	*saturation = c->saturation;
@@ -1321,10 +1320,10 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 98 unmodified lines
1321	1320	int unscaled;
1322	1321	SwsInternal *c = sws_internal(sws);
1323	1322	SwsFilter dummyFilter = { NULL, NULL, NULL, NULL };
1324		− int srcW = c->opts.src_w;
1325		− int srcH = c->opts.src_h;
1326		− int dstW = c->opts.dst_w;
1327		− int dstH = c->opts.dst_h;
	1323	+ int srcW = sws->src_w;
	1324	+ int srcH = sws->src_h;
	1325	+ int dstW = sws->dst_w;
	1326	+ int dstH = sws->dst_h;
1328	1327	int dst_stride = FFALIGN(dstW * sizeof(int16_t) + 66, 16);
1329	1328	int flags, cpu_flags;
1330	1329	enum AVPixelFormat srcFormat, dstFormat;
@@ -1335,25 +1334,25 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 4 unmodified lines
1335	1334	static const float float_mult = 1.0f / 255.0f;
1336	1335
1337	1336	cpu_flags = av_get_cpu_flags();
1338		− flags = c->opts.flags;
	1337	+ flags = sws->flags;
1339	1338	emms_c();
1340	1339
1341	1340	unscaled = (srcW == dstW && srcH == dstH);
1342	1341
1343	1342	if (!c->contrast && !c->saturation && !c->dstFormatBpp)
1344		− sws_setColorspaceDetails(sws, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], c->opts.src_range,
	1343	+ sws_setColorspaceDetails(sws, ff_yuv2rgb_coeffs[SWS_CS_DEFAULT], sws->src_range,
1345	1344	ff_yuv2rgb_coeffs[SWS_CS_DEFAULT],
1346		− c->opts.dst_range, 0, 1 << 16, 1 << 16);
	1345	+ sws->dst_range, 0, 1 << 16, 1 << 16);
1347	1346
1348		− handle_formats(c);
1349		− srcFormat = c->opts.src_format;
1350		− dstFormat = c->opts.dst_format;
	1347	+ handle_formats(sws);
	1348	+ srcFormat = sws->src_format;
	1349	+ dstFormat = sws->dst_format;
1351	1350	desc_src = av_pix_fmt_desc_get(srcFormat);
1352	1351	desc_dst = av_pix_fmt_desc_get(dstFormat);
1353	1352
1354	1353	// If the source has no alpha then disable alpha blendaway
1355	1354	if (c->src0Alpha)
1356		− c->opts.alpha_blend = SWS_ALPHA_BLEND_NONE;
	1355	+ sws->alpha_blend = SWS_ALPHA_BLEND_NONE;
1357	1356
1358	1357	if (!(unscaled && sws_isSupportedEndiannessConversion(srcFormat) &&
1359	1358	av_pix_fmt_swap_endianness(srcFormat) == dstFormat)) {
@@ -1390,7 +1389,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 30 unmodified lines
1390	1389	flags \|= SWS_BICUBIC;
1391	1390	else
1392	1391	flags \|= SWS_BICUBIC;
1393		− c->opts.flags = flags;
	1392	+ sws->flags = flags;
1394	1393	} else if (i & (i - 1)) {
1395	1394	av_log(c, AV_LOG_ERROR,
1396	1395	"Exactly one scaler algorithm must be chosen, got %X\n", i);
@@ -1407,7 +1406,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 10 unmodified lines
1407	1406	if (flags & SWS_FAST_BILINEAR) {
1408	1407	if (srcW < 8 \|\| dstW < 8) {
1409	1408	flags ^= SWS_FAST_BILINEAR \| SWS_BILINEAR;
1410		− c->opts.flags = flags;
	1409	+ sws->flags = flags;
1411	1410	}
1412	1411	}
1413	1412
@@ -1440,46 +1439,46 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 26 unmodified lines
1440	1439	if (dstW&1) {
1441	1440	av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to odd output size\n");
1442	1441	flags \|= SWS_FULL_CHR_H_INT;
1443		− c->opts.flags = flags;
	1442	+ sws->flags = flags;
1444	1443	}
1445	1444
1446	1445	if ( c->chrSrcHSubSample == 0
1447	1446	&& c->chrSrcVSubSample == 0
1448		− && c->opts.dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
1449		− && !(c->opts.flags & SWS_FAST_BILINEAR)
	1447	+ && sws->dither != SWS_DITHER_BAYER //SWS_FULL_CHR_H_INT is currently not supported with SWS_DITHER_BAYER
	1448	+ && !(sws->flags & SWS_FAST_BILINEAR)
1450	1449	) {
1451	1450	av_log(c, AV_LOG_DEBUG, "Forcing full internal H chroma due to input having non subsampled chroma\n");
1452	1451	flags \|= SWS_FULL_CHR_H_INT;
1453		− c->opts.flags = flags;
	1452	+ sws->flags = flags;
1454	1453	}
1455	1454	}
1456	1455
1457		− if (c->opts.dither == SWS_DITHER_AUTO) {
	1456	+ if (sws->dither == SWS_DITHER_AUTO) {
1458	1457	if (flags & SWS_ERROR_DIFFUSION)
1459		− c->opts.dither = SWS_DITHER_ED;
	1458	+ sws->dither = SWS_DITHER_ED;
1460	1459	}
1461	1460
1462	1461	if(dstFormat == AV_PIX_FMT_BGR4_BYTE \|\|
1463	1462	dstFormat == AV_PIX_FMT_RGB4_BYTE \|\|
1464	1463	dstFormat == AV_PIX_FMT_BGR8 \|\|
1465	1464	dstFormat == AV_PIX_FMT_RGB8) {
1466		− if (c->opts.dither == SWS_DITHER_AUTO)
1467		− c->opts.dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
	1465	+ if (sws->dither == SWS_DITHER_AUTO)
	1466	+ sws->dither = (flags & SWS_FULL_CHR_H_INT) ? SWS_DITHER_ED : SWS_DITHER_BAYER;
1468	1467	if (!(flags & SWS_FULL_CHR_H_INT)) {
1469		− if (c->opts.dither == SWS_DITHER_ED \|\| c->opts.dither == SWS_DITHER_A_DITHER \|\| c->opts.dither == SWS_DITHER_X_DITHER \|\| c->opts.dither == SWS_DITHER_NONE) {
	1468	+ if (sws->dither == SWS_DITHER_ED \|\| sws->dither == SWS_DITHER_A_DITHER \|\| sws->dither == SWS_DITHER_X_DITHER \|\| sws->dither == SWS_DITHER_NONE) {
1470	1469	av_log(c, AV_LOG_DEBUG,
1471	1470	"Desired dithering only supported in full chroma interpolation for destination format '%s'\n",
1472	1471	av_get_pix_fmt_name(dstFormat));
1473	1472	flags \|= SWS_FULL_CHR_H_INT;
1474		− c->opts.flags = flags;
	1473	+ sws->flags = flags;
1475	1474	}
1476	1475	}
1477	1476	if (flags & SWS_FULL_CHR_H_INT) {
1478		− if (c->opts.dither == SWS_DITHER_BAYER) {
	1477	+ if (sws->dither == SWS_DITHER_BAYER) {
1479	1478	av_log(c, AV_LOG_DEBUG,
1480	1479	"Ordered dither is not supported in full chroma interpolation for destination format '%s'\n",
1481	1480	av_get_pix_fmt_name(dstFormat));
1482		− c->opts.dither = SWS_DITHER_ED;
	1481	+ sws->dither = SWS_DITHER_ED;
1483	1482	}
1484	1483	}
1485	1484	}
@@ -1489,7 +1488,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 3 unmodified lines
1489	1488	"%s output is not supported with half chroma resolution, switching to full\n",
1490	1489	av_get_pix_fmt_name(dstFormat));
1491	1490	flags \|= SWS_FULL_CHR_H_INT;
1492		− c->opts.flags = flags;
	1491	+ sws->flags = flags;
1493	1492	}
1494	1493	}
1495	1494
@@ -1523,7 +1522,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 27 unmodified lines
1523	1522	"full chroma interpolation for destination format '%s' not yet implemented\n",
1524	1523	av_get_pix_fmt_name(dstFormat));
1525	1524	flags &= ~SWS_FULL_CHR_H_INT;
1526		− c->opts.flags = flags;
	1525	+ sws->flags = flags;
1527	1526	}
1528	1527	if (isAnyRGB(dstFormat) && !(flags & SWS_FULL_CHR_H_INT))
1529	1528	c->chrDstHSubSample = 1;
@@ -1585,7 +1584,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 55 unmodified lines
1585	1584	av_log(c, AV_LOG_INFO,
1586	1585	"output width is not a multiple of 32 -> no MMXEXT scaler\n");
1587	1586	}
1588		− if (usesHFilter \|\| isNBPS(c->opts.src_format) \|\| is16BPS(c->opts.src_format) \|\| isAnyRGB(c->opts.src_format))
	1587	+ if (usesHFilter \|\| isNBPS(sws->src_format) \|\| is16BPS(sws->src_format) \|\| isAnyRGB(sws->src_format))
1589	1588	c->canMMXEXTBeUsed = 0;
1590	1589	} else
1591	1590	c->canMMXEXTBeUsed = 0;
@@ -1616,8 +1615,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 24 unmodified lines
1616	1615	c->gamma_value = 2.2;
1617	1616	tmpFmt = AV_PIX_FMT_RGBA64LE;
1618	1617
1619		−
1620		− if (!unscaled && c->opts.gamma_flag && (srcFormat != tmpFmt \|\| dstFormat != tmpFmt)) {
	1618	+ if (!unscaled && sws->gamma_flag && (srcFormat != tmpFmt \|\| dstFormat != tmpFmt)) {
1621	1619	SwsInternal *c2;
1622	1620	c->cascaded_context[0] = NULL;
1623	1621
@@ -1629,7 +1627,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 5 unmodified lines
1629	1627	c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1630	1628	srcW, srcH, tmpFmt,
1631	1629	flags, NULL, NULL,
1632		− c->opts.scaler_params);
	1630	+ sws->scaler_params);
1633	1631	if (!c->cascaded_context[0]) {
1634	1632	return AVERROR(ENOMEM);
1635	1633	}
@@ -1637,7 +1635,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 1 unmodified line
1637	1635	c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFmt,
1638	1636	dstW, dstH, tmpFmt,
1639	1637	flags, srcFilter, dstFilter,
1640		− c->opts.scaler_params);
	1638	+ sws->scaler_params);
1641	1639
1642	1640	if (!c->cascaded_context[1])
1643	1641	return AVERROR(ENOMEM);
@@ -1669,7 +1667,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 25 unmodified lines
1669	1667	c->cascaded_context[2] = sws_getContext(dstW, dstH, tmpFmt,
1670	1668	dstW, dstH, dstFormat,
1671	1669	flags, NULL, NULL,
1672		− c->opts.scaler_params);
	1670	+ sws->scaler_params);
1673	1671	if (!c->cascaded_context[2])
1674	1672	return AVERROR(ENOMEM);
1675	1673	}
@@ -1690,14 +1688,14 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 14 unmodified lines
1690	1688	c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
1691	1689	srcW, srcH, tmpFormat,
1692	1690	flags, srcFilter, NULL,
1693		− c->opts.scaler_params);
	1691	+ sws->scaler_params);
1694	1692	if (!c->cascaded_context[0])
1695	1693	return AVERROR(ENOMEM);
1696	1694
1697	1695	c->cascaded_context[1] = sws_getContext(srcW, srcH, tmpFormat,
1698	1696	dstW, dstH, dstFormat,
1699	1697	flags, NULL, dstFilter,
1700		− c->opts.scaler_params);
	1698	+ sws->scaler_params);
1701	1699	if (!c->cascaded_context[1])
1702	1700	return AVERROR(ENOMEM);
1703	1701	return 0;
@@ -1720,11 +1718,11 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 16 unmodified lines
1720	1718	if (CONFIG_SWSCALE_ALPHA && isALPHA(srcFormat) && !isALPHA(dstFormat)) {
1721	1719	enum AVPixelFormat tmpFormat = alphaless_fmt(srcFormat);
1722	1720
1723		− if (tmpFormat != AV_PIX_FMT_NONE && c->opts.alpha_blend != SWS_ALPHA_BLEND_NONE) {
	1721	+ if (tmpFormat != AV_PIX_FMT_NONE && sws->alpha_blend != SWS_ALPHA_BLEND_NONE) {
1724	1722	if (!unscaled \|\|
1725	1723	dstFormat != tmpFormat \|\|
1726	1724	usesHFilter \|\| usesVFilter \|\|
1727		− c->opts.src_range != c->opts.dst_range
	1725	+ sws->src_range != sws->dst_range
1728	1726	) {
1729	1727	c->cascaded_mainindex = 1;
1730	1728	ret = av_image_alloc(c->cascaded_tmp[0], c->cascaded_tmpStride[0],
@@ -1734,22 +1732,22 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 3 unmodified lines
1734	1732
1735	1733	c->cascaded_context[0] = alloc_set_opts(srcW, srcH, srcFormat,
1736	1734	srcW, srcH, tmpFormat,
1737		− flags, c->opts.scaler_params);
	1735	+ flags, sws->scaler_params);
1738	1736	if (!c->cascaded_context[0])
1739	1737	return AVERROR(EINVAL);
1740		− sws_internal(c->cascaded_context[0])->opts.alpha_blend = c->opts.alpha_blend;
	1738	+ c->cascaded_context[0]->alpha_blend = sws->alpha_blend;
1741	1739	ret = sws_init_context(c->cascaded_context[0], NULL , NULL);
1742	1740	if (ret < 0)
1743	1741	return ret;
1744	1742
1745	1743	c->cascaded_context[1] = alloc_set_opts(srcW, srcH, tmpFormat,
1746	1744	dstW, dstH, dstFormat,
1747		− flags, c->opts.scaler_params);
	1745	+ flags, sws->scaler_params);
1748	1746	if (!c->cascaded_context[1])
1749	1747	return AVERROR(EINVAL);
1750	1748
1751		− sws_internal(c->cascaded_context[1])->opts.src_range = c->opts.src_range;
1752		− sws_internal(c->cascaded_context[1])->opts.dst_range = c->opts.dst_range;
	1749	+ c->cascaded_context[1]->src_range = sws->src_range;
	1750	+ c->cascaded_context[1]->dst_range = sws->dst_range;
1753	1751	ret = sws_init_context(c->cascaded_context[1], srcFilter , dstFilter);
1754	1752	if (ret < 0)
1755	1753	return ret;
@@ -1761,9 +1759,9 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 5 unmodified lines
1761	1759
1762	1760	/* alpha blend special case, note this has been split via cascaded contexts if its scaled */
1763	1761	if (unscaled && !usesHFilter && !usesVFilter &&
1764		− c->opts.alpha_blend != SWS_ALPHA_BLEND_NONE &&
	1762	+ sws->alpha_blend != SWS_ALPHA_BLEND_NONE &&
1765	1763	isALPHA(srcFormat) &&
1766		− (c->opts.src_range == c->opts.dst_range \|\| isAnyRGB(dstFormat)) &&
	1764	+ (sws->src_range == sws->dst_range \|\| isAnyRGB(dstFormat)) &&
1767	1765	alphaless_fmt(srcFormat) == dstFormat
1768	1766	) {
1769	1767	c->convert_unscaled = ff_sws_alphablendaway;
@@ -1777,7 +1775,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 7 unmodified lines
1777	1775
1778	1776	/* unscaled special cases */
1779	1777	if (unscaled && !usesHFilter && !usesVFilter &&
1780		− (c->opts.src_range == c->opts.dst_range \|\| isAnyRGB(dstFormat) \|\|
	1778	+ (sws->src_range == sws->dst_range \|\| isAnyRGB(dstFormat) \|\|
1781	1779	isFloat(srcFormat) \|\| isFloat(dstFormat) \|\| isBayer(srcFormat))){
1782	1780
1783	1781	ff_get_unscaled_swscale(c);
@@ -1873,7 +1871,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 89 unmodified lines
1873	1871	srcW, dstW, filterAlign, 1 << 14,
1874	1872	(flags & SWS_BICUBLIN) ? (flags \| SWS_BICUBIC) : flags,
1875	1873	cpu_flags, srcFilter->lumH, dstFilter->lumH,
1876		− c->opts.scaler_params,
	1874	+ sws->scaler_params,
1877	1875	get_local_pos(c, 0, 0, 0),
1878	1876	get_local_pos(c, 0, 0, 0))) < 0)
1879	1877	goto fail;
@@ -1884,9 +1882,9 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 4 unmodified lines
1884	1882	c->chrSrcW, c->chrDstW, filterAlign, 1 << 14,
1885	1883	(flags & SWS_BICUBLIN) ? (flags \| SWS_BILINEAR) : flags,
1886	1884	cpu_flags, srcFilter->chrH, dstFilter->chrH,
1887		− c->opts.scaler_params,
1888		− get_local_pos(c, c->chrSrcHSubSample, c->opts.src_h_chr_pos, 0),
1889		− get_local_pos(c, c->chrDstHSubSample, c->opts.dst_h_chr_pos, 0))) < 0)
	1885	+ sws->scaler_params,
	1886	+ get_local_pos(c, c->chrSrcHSubSample, sws->src_h_chr_pos, 0),
	1887	+ get_local_pos(c, c->chrDstHSubSample, sws->dst_h_chr_pos, 0))) < 0)
1890	1888	goto fail;
1891	1889	if (ff_shuffle_filter_coefficients(c, c->hChrFilterPos, c->hChrFilterSize, c->hChrFilter, c->chrDstW) < 0)
1892	1890	goto nomem;
@@ -1903,7 +1901,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 10 unmodified lines
1903	1901	c->lumYInc, srcH, dstH, filterAlign, (1 << 12),
1904	1902	(flags & SWS_BICUBLIN) ? (flags \| SWS_BICUBIC) : flags,
1905	1903	cpu_flags, srcFilter->lumV, dstFilter->lumV,
1906		− c->opts.scaler_params,
	1904	+ sws->scaler_params,
1907	1905	get_local_pos(c, 0, 0, 1),
1908	1906	get_local_pos(c, 0, 0, 1))) < 0)
1909	1907	goto fail;
@@ -1912,18 +1910,18 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 2 unmodified lines
1912	1910	filterAlign, (1 << 12),
1913	1911	(flags & SWS_BICUBLIN) ? (flags \| SWS_BILINEAR) : flags,
1914	1912	cpu_flags, srcFilter->chrV, dstFilter->chrV,
1915		− c->opts.scaler_params,
1916		− get_local_pos(c, c->chrSrcVSubSample, c->opts.src_v_chr_pos, 1),
1917		− get_local_pos(c, c->chrDstVSubSample, c->opts.dst_v_chr_pos, 1))) < 0)
	1913	+ sws->scaler_params,
	1914	+ get_local_pos(c, c->chrSrcVSubSample, sws->src_v_chr_pos, 1),
	1915	+ get_local_pos(c, c->chrDstVSubSample, sws->dst_v_chr_pos, 1))) < 0)
1918	1916
1919	1917	goto fail;
1920	1918
1921	1919	#if HAVE_ALTIVEC
1922		− if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * c->opts.dst_h) \|\|
	1920	+ if (!FF_ALLOC_TYPED_ARRAY(c->vYCoeffsBank, c->vLumFilterSize * sws->dst_h) \|\|
1923	1921	!FF_ALLOC_TYPED_ARRAY(c->vCCoeffsBank, c->vChrFilterSize * c->chrDstH))
1924	1922	goto nomem;
1925	1923
1926		− for (i = 0; i < c->vLumFilterSize * c->opts.dst_h; i++) {
	1924	+ for (i = 0; i < c->vLumFilterSize * sws->dst_h; i++) {
1927	1925	int j;
1928	1926	short p = (short )&c->vYCoeffsBank[i];
1929	1927	for (j = 0; j < 8; j++)
@@ -1940,10 +1938,10 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 10 unmodified lines
1940	1938	}
1941	1939
1942	1940	for (i = 0; i < 4; i++)
1943		− if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], c->opts.dst_w + 3))
	1941	+ if (!FF_ALLOCZ_TYPED_ARRAY(c->dither_error[i], sws->dst_w + 3))
1944	1942	goto nomem;
1945	1943
1946		− c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(c->opts.src_format) && isALPHA(c->opts.dst_format)) ? 1 : 0;
	1944	+ c->needAlpha = (CONFIG_SWSCALE_ALPHA && isALPHA(sws->src_format) && isALPHA(sws->dst_format)) ? 1 : 0;
1947	1945
1948	1946	// 64 / c->scalingBpp is the same as 16 / sizeof(scaling_intermediate)
1949	1947	c->uv_off = (dst_stride>>1) + 64 / (c->dstBpc &~ 7);
@@ -1985,7 +1983,7 @@ static av_cold int sws_init_single_context(SwsContext sws, SwsFilter srcFilter · 35 unmodified lines
1985	1983	av_log(c, AV_LOG_VERBOSE, "%dx%d -> %dx%d\n", srcW, srcH, dstW, dstH);
1986	1984	av_log(c, AV_LOG_DEBUG,
1987	1985	"lum srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1988		− c->opts.src_w, c->opts.src_h, c->opts.dst_w, c->opts.dst_h, c->lumXInc, c->lumYInc);
	1986	+ sws->src_w, sws->src_h, sws->dst_w, sws->dst_h, c->lumXInc, c->lumYInc);
1989	1987	av_log(c, AV_LOG_DEBUG,
1990	1988	"chr srcW=%d srcH=%d dstW=%d dstH=%d xInc=%d yInc=%d\n",
1991	1989	c->chrSrcW, c->chrSrcH, c->chrDstW, c->chrDstH,
@@ -2017,14 +2015,14 @@ fail: // FIXME replace things by appropriate error codes · 25 unmodified lines
2017	2015	c->cascaded_context[0] = sws_getContext(srcW, srcH, srcFormat,
2018	2016	tmpW, tmpH, tmpFormat,
2019	2017	flags, srcFilter, NULL,
2020		− c->opts.scaler_params);
	2018	+ sws->scaler_params);
2021	2019	if (!c->cascaded_context[0])
2022	2020	return AVERROR(ENOMEM);
2023	2021
2024	2022	c->cascaded_context[1] = sws_getContext(tmpW, tmpH, tmpFormat,
2025	2023	dstW, dstH, dstFormat,
2026	2024	flags, NULL, dstFilter,
2027		− c->opts.scaler_params);
	2025	+ sws->scaler_params);
2028	2026	if (!c->cascaded_context[1])
2029	2027	return AVERROR(ENOMEM);
2030	2028	return 0;
@@ -2039,41 +2037,38 @@ static int context_init_threaded(SwsContext *sws, · 8 unmodified lines
2039	2037	int ret;
2040	2038
2041	2039	ret = avpriv_slicethread_create(&c->slicethread, (void*) sws,
2042		− ff_sws_slice_worker, NULL, c->opts.threads);
	2040	+ ff_sws_slice_worker, NULL, sws->threads);
2043	2041	if (ret == AVERROR(ENOSYS)) {
2044		− c->opts.threads = 1;
	2042	+ sws->threads = 1;
2045	2043	return 0;
2046	2044	} else if (ret < 0)
2047	2045	return ret;
2048	2046
2049		− c->opts.threads = ret;
	2047	+ sws->threads = ret;
2050	2048
2051		− c->slice_ctx = av_calloc(c->opts.threads, sizeof(*c->slice_ctx));
2052		− c->slice_err = av_calloc(c->opts.threads, sizeof(*c->slice_err));
	2049	+ c->slice_ctx = av_calloc(sws->threads, sizeof(*c->slice_ctx));
	2050	+ c->slice_err = av_calloc(sws->threads, sizeof(*c->slice_err));
2053	2051	if (!c->slice_ctx \|\| !c->slice_err)
2054	2052	return AVERROR(ENOMEM);
2055	2053
2056		− for (int i = 0; i < c->opts.threads; i++) {
2057		− SwsInternal *c2;
2058		− c->slice_ctx[i] = sws_alloc_context();
2059		− if (!c->slice_ctx[i])
	2054	+ for (int i = 0; i < sws->threads; i++) {
	2055	+ SwsContext *slice;
	2056	+ slice = c->slice_ctx[i] = sws_alloc_context();
	2057	+ if (!slice)
2060	2058	return AVERROR(ENOMEM);
2061		− c2 = sws_internal(c->slice_ctx[i]);
2062		−
	2059	+ sws_internal(slice)->parent = sws;
2063	2060	c->nb_slice_ctx++;
2064		− c2->parent = sws;
2065	2061
2066		− ret = av_opt_copy((void)c->slice_ctx[i], (void)c);
	2062	+ ret = av_opt_copy(slice, sws);
2067	2063	if (ret < 0)
2068	2064	return ret;
	2065	+ slice->threads = 1;
2069	2066
2070		− c2->opts.threads = 1;
2071		−
2072		− ret = sws_init_single_context(c->slice_ctx[i], src_filter, dst_filter);
	2067	+ ret = sws_init_single_context(slice, src_filter, dst_filter);
2073	2068	if (ret < 0)
2074	2069	return ret;
2075	2070
2076		− if (c2->opts.dither == SWS_DITHER_ED) {
	2071	+ if (slice->dither == SWS_DITHER_ED) {
2077	2072	av_log(c, AV_LOG_VERBOSE,
2078	2073	"Error-diffusion dither is in use, scaling will be single-threaded.");
2079	2074	break;
@@ -2099,17 +2094,17 @@ av_cold int sws_init_context(SwsContext sws, SwsFilter srcFilter, · 19 unmodified lines
2099	2094	if (ff_thread_once(&rgb2rgb_once, ff_sws_rgb2rgb_init) != 0)
2100	2095	return AVERROR_UNKNOWN;
2101	2096
2102		− src_format = c->opts.src_format;
2103		− dst_format = c->opts.dst_format;
2104		− c->opts.src_range \|= handle_jpeg(&c->opts.src_format);
2105		− c->opts.dst_range \|= handle_jpeg(&c->opts.dst_format);
	2097	+ src_format = sws->src_format;
	2098	+ dst_format = sws->dst_format;
	2099	+ sws->src_range \|= handle_jpeg(&sws->src_format);
	2100	+ sws->dst_range \|= handle_jpeg(&sws->dst_format);
2106	2101
2107		− if (src_format != c->opts.src_format \|\| dst_format != c->opts.dst_format)
	2102	+ if (src_format != sws->src_format \|\| dst_format != sws->dst_format)
2108	2103	av_log(c, AV_LOG_WARNING, "deprecated pixel format used, make sure you did set range correctly\n");
2109	2104
2110		− if (c->opts.threads != 1) {
	2105	+ if (sws->threads != 1) {
2111	2106	ret = context_init_threaded(sws, srcFilter, dstFilter);
2112		− if (ret < 0 \|\| c->opts.threads > 1)
	2107	+ if (ret < 0 \|\| sws->threads > 1)
2113	2108	return ret;
2114	2109	// threading disabled in this build, init as single-threaded
2115	2110	}

tests/checkasm/sw_gbrp.c+8−8

@@ -135,13 +135,13 @@ static void check_output_yuv2gbrp(void) · 134 unmodified lines
135	135	fail();
136	136
137	137	c = sws_internal(sws);
138		− c->opts.flags \|= SWS_FULL_CHR_H_INT;
	138	+ sws->flags \|= SWS_FULL_CHR_H_INT;
139	139
140	140	for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
141	141	for (fsi = 0; fsi < FILTER_SIZES; fsi++) {
142	142	for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
143	143	desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
144		− c->opts.dst_format = planar_fmts[fmi];
	144	+ sws->dst_format = planar_fmts[fmi];
145	145
146	146	dstW = input_sizes[isi];
147	147	luma_filter_size = filter_sizes[fsi];
@@ -229,8 +229,8 @@ static void check_input_planar_rgb_to_y(void) · 81 unmodified lines
229	229	for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
230	230	for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
231	231	desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
232		− c->opts.src_format = planar_fmts[fmi];
233		− c->opts.dst_format = AV_PIX_FMT_YUVA444P16;
	232	+ sws->src_format = planar_fmts[fmi];
	233	+ sws->dst_format = AV_PIX_FMT_YUVA444P16;
234	234	byte_size = 2;
235	235	dstW = input_sizes[isi];
236	236
@@ -300,8 +300,8 @@ static void check_input_planar_rgb_to_uv(void) · 63 unmodified lines
300	300	for (fmi = 0; fmi < FF_ARRAY_ELEMS(planar_fmts); fmi++) {
301	301	for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); isi++ ) {
302	302	desc = av_pix_fmt_desc_get(planar_fmts[fmi]);
303		− c->opts.src_format = planar_fmts[fmi];
304		− c->opts.dst_format = AV_PIX_FMT_YUVA444P16;
	303	+ sws->src_format = planar_fmts[fmi];
	304	+ sws->dst_format = AV_PIX_FMT_YUVA444P16;
305	305	byte_size = 2;
306	306	dstW = input_sizes[isi];
307	307
@@ -373,8 +373,8 @@ static void check_input_planar_rgb_to_a(void) · 65 unmodified lines
373	373	if (!(desc->flags & AV_PIX_FMT_FLAG_ALPHA))
374	374	continue;
375	375
376		− c->opts.src_format = planar_fmts[fmi];
377		− c->opts.dst_format = AV_PIX_FMT_YUVA444P16;
	376	+ sws->src_format = planar_fmts[fmi];
	377	+ sws->dst_format = AV_PIX_FMT_YUVA444P16;
378	378	byte_size = 2;
379	379	dstW = input_sizes[isi];
380	380

tests/checkasm/sw_range_convert.c+8−8

@@ -73,16 +73,16 @@ static void check_lumConvertRange(int from) · 72 unmodified lines
73	73	fail();
74	74
75	75	c = sws_internal(sws);
76		− c->opts.src_range = from;
77		− c->opts.dst_range = !from;
	76	+ sws->src_range = from;
	77	+ sws->dst_range = !from;
78	78
79	79	for (int pfi = 0; pfi < FF_ARRAY_ELEMS(pixel_formats); pfi++) {
80	80	enum AVPixelFormat pix_fmt = pixel_formats[pfi];
81	81	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
82	82	int bit_depth = desc->comp[0].depth;
83	83	int sample_size = bit_depth == 16 ? sizeof(int32_t) : sizeof(int16_t);
84		− c->opts.src_format = pix_fmt;
85		− c->opts.dst_format = pix_fmt;
	84	+ sws->src_format = pix_fmt;
	85	+ sws->dst_format = pix_fmt;
86	86	c->dstBpc = bit_depth;
87	87	ff_sws_init_scale(c);
88	88	for (int dstWi = 0; dstWi < FF_ARRAY_ELEMS(input_sizes); dstWi++) {
@@ -123,16 +123,16 @@ static void check_chrConvertRange(int from) · 34 unmodified lines
123	123	fail();
124	124
125	125	c = sws_internal(sws);
126		− c->opts.src_range = from;
127		− c->opts.dst_range = !from;
	126	+ sws->src_range = from;
	127	+ sws->dst_range = !from;
128	128
129	129	for (int pfi = 0; pfi < FF_ARRAY_ELEMS(pixel_formats); pfi++) {
130	130	enum AVPixelFormat pix_fmt = pixel_formats[pfi];
131	131	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
132	132	int bit_depth = desc->comp[0].depth;
133	133	int sample_size = bit_depth == 16 ? sizeof(int32_t) : sizeof(int16_t);
134		− c->opts.src_format = pix_fmt;
135		− c->opts.dst_format = pix_fmt;
	134	+ sws->src_format = pix_fmt;
	135	+ sws->dst_format = pix_fmt;
136	136	c->dstBpc = bit_depth;
137	137	ff_sws_init_scale(c);
138	138	for (int dstWi = 0; dstWi < FF_ARRAY_ELEMS(input_sizes); dstWi++) {

tests/checkasm/sw_rgb.c+16−13

@@ -127,9 +127,10 @@ static int cmp_off_by_n(const uint8_t ref, const uint8_t test, size_t n, int a · 126 unmodified lines
127	127	return 0;
128	128	}
129	129
130		−static void check_rgb24toyv12(SwsInternal *ctx)
	130	+static void check_rgb24toyv12(SwsContext *sws)
131	131	{
132	132	static const int input_sizes[] = {16, 128, 512, MAX_LINE_SIZE, -MAX_LINE_SIZE};
	133	+ SwsInternal *ctx = sws_internal(sws);
133	134
134	135	LOCAL_ALIGNED_32(uint8_t, src, [BUFSIZE * 3]);
135	136	LOCAL_ALIGNED_32(uint8_t, buf_y_0, [BUFSIZE]);
@@ -353,8 +354,10 @@ static const enum AVPixelFormat rgb_formats[] = { · 217 unmodified lines
353	354	AV_PIX_FMT_ARGB,
354	355	};
355	356
356		−static void check_rgb_to_y(SwsInternal *ctx)
	357	+static void check_rgb_to_y(SwsContext *sws)
357	358	{
	359	+ SwsInternal *ctx = sws_internal(sws);
	360	+
358	361	LOCAL_ALIGNED_16(uint8_t, src24, [MAX_LINE_SIZE * 3]);
359	362	LOCAL_ALIGNED_16(uint8_t, src32, [MAX_LINE_SIZE * 4]);
360	363	LOCAL_ALIGNED_32(uint8_t, dst0_y, [MAX_LINE_SIZE * 2]);
@@ -370,7 +373,7 @@ static void check_rgb_to_y(SwsInternal *ctx) · 9 unmodified lines
370	373	for (int i = 0; i < FF_ARRAY_ELEMS(rgb_formats); i++) {
371	374	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(rgb_formats[i]);
372	375
373		− ctx->opts.src_format = rgb_formats[i];
	376	+ sws->src_format = rgb_formats[i];
374	377	ff_sws_init_scale(ctx);
375	378
376	379	for (int j = 0; j < FF_ARRAY_ELEMS(input_sizes); j++) {
@@ -389,15 +392,17 @@ static void check_rgb_to_y(SwsInternal *ctx) · 12 unmodified lines
389	392
390	393	if (desc->nb_components == 3 \|\|
391	394	// only bench native endian formats
392		− (ctx->opts.src_format == AV_PIX_FMT_RGB32 \|\| ctx->opts.src_format == AV_PIX_FMT_RGB32_1))
	395	+ (sws->src_format == AV_PIX_FMT_RGB32 \|\| sws->src_format == AV_PIX_FMT_RGB32_1))
393	396	bench_new(dst1_y, src, NULL, NULL, w, ctx->input_rgb2yuv_table, NULL);
394	397	}
395	398	}
396	399	}
397	400	}
398	401
399		−static void check_rgb_to_uv(SwsInternal *ctx)
	402	+static void check_rgb_to_uv(SwsContext *sws)
400	403	{
	404	+ SwsInternal *ctx = sws_internal(sws);
	405	+
401	406	LOCAL_ALIGNED_16(uint8_t, src24, [MAX_LINE_SIZE * 3]);
402	407	LOCAL_ALIGNED_16(uint8_t, src32, [MAX_LINE_SIZE * 4]);
403	408	LOCAL_ALIGNED_16(uint8_t, dst0_u, [MAX_LINE_SIZE * 2]);
@@ -417,8 +422,8 @@ static void check_rgb_to_uv(SwsInternal *ctx) · 13 unmodified lines
417	422	const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src_fmt);
418	423
419	424	ctx->chrSrcHSubSample = (i % 2) ? 0 : 1;
420		− ctx->opts.src_format = src_fmt;
421		− ctx->opts.dst_format = ctx->chrSrcHSubSample ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUV444P;
	425	+ sws->src_format = src_fmt;
	426	+ sws->dst_format = ctx->chrSrcHSubSample ? AV_PIX_FMT_YUV420P : AV_PIX_FMT_YUV444P;
422	427	ff_sws_init_scale(ctx);
423	428
424	429	for (int j = 0; j < FF_ARRAY_ELEMS(input_sizes); j++) {
@@ -441,7 +446,7 @@ static void check_rgb_to_uv(SwsInternal *ctx) · 16 unmodified lines
441	446
442	447	if (desc->nb_components == 3 \|\|
443	448	// only bench native endian formats
444		− (ctx->opts.src_format == AV_PIX_FMT_RGB32 \|\| ctx->opts.src_format == AV_PIX_FMT_RGB32_1))
	449	+ (sws->src_format == AV_PIX_FMT_RGB32 \|\| sws->src_format == AV_PIX_FMT_RGB32_1))
445	450	bench_new(dst1_u, dst1_v, NULL, src, src, w, ctx->input_rgb2yuv_table, NULL);
446	451	}
447	452	}
@@ -451,7 +456,6 @@ static void check_rgb_to_uv(SwsInternal *ctx) · 3 unmodified lines
451	456	void checkasm_check_sw_rgb(void)
452	457	{
453	458	SwsContext *sws;
454		− SwsInternal *c;
455	459
456	460	ff_sws_rgb2rgb_init();
457	461
@@ -485,14 +489,13 @@ void checkasm_check_sw_rgb(void) · 27 unmodified lines
485	489	if (!sws)
486	490	fail();
487	491
488		− c = sws_internal(sws);
489		− check_rgb_to_y(c);
	492	+ check_rgb_to_y(sws);
490	493	report("rgb_to_y");
491	494
492		− check_rgb_to_uv(c);
	495	+ check_rgb_to_uv(sws);
493	496	report("rgb_to_uv");
494	497
495		− check_rgb24toyv12(c);
	498	+ check_rgb24toyv12(sws);
496	499	report("rgb24toyv12");
497	500
498	501	sws_freeContext(sws);

tests/checkasm/sw_scale.c+11−11

@@ -123,12 +123,12 @@ static void check_yuv2yuv1(int accurate) · 122 unmodified lines
123	123	randomize_buffers((uint8_t*)dither, 8);
124	124	randomize_buffers((uint8_t)src_pixels, LARGEST_INPUT_SIZE sizeof(int16_t));
125	125	sws = sws_alloc_context();
126		− c = sws_internal(sws);
127	126	if (accurate)
128		− c->opts.flags \|= SWS_ACCURATE_RND;
	127	+ sws->flags \|= SWS_ACCURATE_RND;
129	128	if (sws_init_context(sws, NULL, NULL) < 0)
130	129	fail();
131	130
	131	+ c = sws_internal(sws);
132	132	ff_sws_init_scale(c);
133	133	for (isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); ++isi) {
134	134	dstW = input_sizes[isi];
@@ -190,12 +190,12 @@ static void check_yuv2yuvX(int accurate) · 55 unmodified lines
190	190	memset(dither, d_val, LARGEST_INPUT_SIZE);
191	191	randomize_buffers((uint8_t)src_pixels, LARGEST_FILTER LARGEST_INPUT_SIZE * sizeof(int16_t));
192	192	sws = sws_alloc_context();
193		− c = sws_internal(sws);
194	193	if (accurate)
195		− c->opts.flags \|= SWS_ACCURATE_RND;
	194	+ sws->flags \|= SWS_ACCURATE_RND;
196	195	if (sws_init_context(sws, NULL, NULL) < 0)
197	196	fail();
198	197
	198	+ c = sws_internal(sws);
199	199	ff_sws_init_scale(c);
200	200	for(isi = 0; isi < FF_ARRAY_ELEMS(input_sizes); ++isi){
201	201	dstW = input_sizes[isi];
@@ -341,20 +341,20 @@ static void check_hscale(void) · 139 unmodified lines
341	341
342	342	filter[SRC_PIXELS * width + i] = rnd();
343	343	}
344		− c->opts.dst_w = c->chrDstW = input_sizes[dstWi];
	344	+ sws->dst_w = c->chrDstW = input_sizes[dstWi];
345	345	ff_sws_init_scale(c);
346	346	memcpy(filterAvx2, filter, sizeof(uint16_t) * (SRC_PIXELS * MAX_FILTER_WIDTH + MAX_FILTER_WIDTH));
347		− ff_shuffle_filter_coefficients(c, filterPosAvx, width, filterAvx2, c->opts.dst_w);
	347	+ ff_shuffle_filter_coefficients(c, filterPosAvx, width, filterAvx2, sws->dst_w);
348	348
349		− if (check_func(c->hcScale, "hscale_%d_to_%d__fs_%d_dstW_%d", c->srcBpc, c->dstBpc + 1, width, c->opts.dst_w)) {
	349	+ if (check_func(c->hcScale, "hscale_%d_to_%d__fs_%d_dstW_%d", c->srcBpc, c->dstBpc + 1, width, sws->dst_w)) {
350	350	memset(dst0, 0, SRC_PIXELS * sizeof(dst0[0]));
351	351	memset(dst1, 0, SRC_PIXELS * sizeof(dst1[0]));
352	352
353		− call_ref(NULL, dst0, c->opts.dst_w, src, filter, filterPos, width);
354		− call_new(NULL, dst1, c->opts.dst_w, src, filterAvx2, filterPosAvx, width);
355		− if (memcmp(dst0, dst1, c->opts.dst_w * sizeof(dst0[0])))
	353	+ call_ref(NULL, dst0, sws->dst_w, src, filter, filterPos, width);
	354	+ call_new(NULL, dst1, sws->dst_w, src, filterAvx2, filterPosAvx, width);
	355	+ if (memcmp(dst0, dst1, sws->dst_w * sizeof(dst0[0])))
356	356	fail();
357		− bench_new(NULL, dst0, c->opts.dst_w, src, filter, filterPosAvx, width);
	357	+ bench_new(NULL, dst0, sws->dst_w, src, filter, filterPosAvx, width);
358	358	}
359	359	}
360	360	}

swscale: eliminate redundant SwsInternal accesses

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code