Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * VC3/DNxHD encoder | ||
3 | * Copyright (c) 2007 Baptiste Coudurier <baptiste dot coudurier at smartjog dot com> | ||
4 | * Copyright (c) 2011 MirriAd Ltd | ||
5 | * | ||
6 | * VC-3 encoder funded by the British Broadcasting Corporation | ||
7 | * 10 bit support added by MirriAd Ltd, Joseph Artsimovich <joseph@mirriad.com> | ||
8 | * | ||
9 | * This file is part of FFmpeg. | ||
10 | * | ||
11 | * FFmpeg is free software; you can redistribute it and/or | ||
12 | * modify it under the terms of the GNU Lesser General Public | ||
13 | * License as published by the Free Software Foundation; either | ||
14 | * version 2.1 of the License, or (at your option) any later version. | ||
15 | * | ||
16 | * FFmpeg is distributed in the hope that it will be useful, | ||
17 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
18 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
19 | * Lesser General Public License for more details. | ||
20 | * | ||
21 | * You should have received a copy of the GNU Lesser General Public | ||
22 | * License along with FFmpeg; if not, write to the Free Software | ||
23 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
24 | */ | ||
25 | |||
26 | #include "libavutil/attributes.h" | ||
27 | #include "libavutil/internal.h" | ||
28 | #include "libavutil/mem.h" | ||
29 | #include "libavutil/mem_internal.h" | ||
30 | #include "libavutil/opt.h" | ||
31 | |||
32 | #include "avcodec.h" | ||
33 | #include "blockdsp.h" | ||
34 | #include "codec_internal.h" | ||
35 | #include "encode.h" | ||
36 | #include "fdctdsp.h" | ||
37 | #include "mathops.h" | ||
38 | #include "mpegvideo.h" | ||
39 | #include "mpegvideoenc.h" | ||
40 | #include "pixblockdsp.h" | ||
41 | #include "packet_internal.h" | ||
42 | #include "profiles.h" | ||
43 | #include "dnxhdenc.h" | ||
44 | |||
45 | // The largest value that will not lead to overflow for 10-bit samples. | ||
46 | #define DNX10BIT_QMAT_SHIFT 18 | ||
47 | #define RC_VARIANCE 1 // use variance or ssd for fast rc | ||
48 | #define LAMBDA_FRAC_BITS 10 | ||
49 | |||
50 | #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM | ||
51 | static const AVOption options[] = { | ||
52 | { "nitris_compat", "encode with Avid Nitris compatibility", | ||
53 | offsetof(DNXHDEncContext, nitris_compat), AV_OPT_TYPE_BOOL, { .i64 = 0 }, 0, 1, VE }, | ||
54 | { "ibias", "intra quant bias", | ||
55 | offsetof(DNXHDEncContext, intra_quant_bias), AV_OPT_TYPE_INT, | ||
56 | { .i64 = 0 }, INT_MIN, INT_MAX, VE }, | ||
57 | { "profile", NULL, offsetof(DNXHDEncContext, profile), AV_OPT_TYPE_INT, | ||
58 | { .i64 = AV_PROFILE_DNXHD }, | ||
59 | AV_PROFILE_DNXHD, AV_PROFILE_DNXHR_444, VE, .unit = "profile" }, | ||
60 | { "dnxhd", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHD }, | ||
61 | 0, 0, VE, .unit = "profile" }, | ||
62 | { "dnxhr_444", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_444 }, | ||
63 | 0, 0, VE, .unit = "profile" }, | ||
64 | { "dnxhr_hqx", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_HQX }, | ||
65 | 0, 0, VE, .unit = "profile" }, | ||
66 | { "dnxhr_hq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_HQ }, | ||
67 | 0, 0, VE, .unit = "profile" }, | ||
68 | { "dnxhr_sq", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_SQ }, | ||
69 | 0, 0, VE, .unit = "profile" }, | ||
70 | { "dnxhr_lb", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_PROFILE_DNXHR_LB }, | ||
71 | 0, 0, VE, .unit = "profile" }, | ||
72 | { NULL } | ||
73 | }; | ||
74 | |||
75 | static const AVClass dnxhd_class = { | ||
76 | .class_name = "dnxhd", | ||
77 | .item_name = av_default_item_name, | ||
78 | .option = options, | ||
79 | .version = LIBAVUTIL_VERSION_INT, | ||
80 | }; | ||
81 | |||
82 | 97920 | static void dnxhd_8bit_get_pixels_8x4_sym(int16_t *restrict block, | |
83 | const uint8_t *pixels, | ||
84 | ptrdiff_t line_size) | ||
85 | { | ||
86 | int i; | ||
87 |
2/2✓ Branch 0 taken 391680 times.
✓ Branch 1 taken 97920 times.
|
489600 | for (i = 0; i < 4; i++) { |
88 | 391680 | block[0] = pixels[0]; | |
89 | 391680 | block[1] = pixels[1]; | |
90 | 391680 | block[2] = pixels[2]; | |
91 | 391680 | block[3] = pixels[3]; | |
92 | 391680 | block[4] = pixels[4]; | |
93 | 391680 | block[5] = pixels[5]; | |
94 | 391680 | block[6] = pixels[6]; | |
95 | 391680 | block[7] = pixels[7]; | |
96 | 391680 | pixels += line_size; | |
97 | 391680 | block += 8; | |
98 | } | ||
99 | 97920 | memcpy(block, block - 8, sizeof(*block) * 8); | |
100 | 97920 | memcpy(block + 8, block - 16, sizeof(*block) * 8); | |
101 | 97920 | memcpy(block + 16, block - 24, sizeof(*block) * 8); | |
102 | 97920 | memcpy(block + 24, block - 32, sizeof(*block) * 8); | |
103 | 97920 | } | |
104 | |||
105 | static av_always_inline | ||
106 | 43200 | void dnxhd_10bit_get_pixels_8x4_sym(int16_t *restrict block, | |
107 | const uint8_t *pixels, | ||
108 | ptrdiff_t line_size) | ||
109 | { | ||
110 | 43200 | memcpy(block + 0 * 8, pixels + 0 * line_size, 8 * sizeof(*block)); | |
111 | 43200 | memcpy(block + 7 * 8, pixels + 0 * line_size, 8 * sizeof(*block)); | |
112 | 43200 | memcpy(block + 1 * 8, pixels + 1 * line_size, 8 * sizeof(*block)); | |
113 | 43200 | memcpy(block + 6 * 8, pixels + 1 * line_size, 8 * sizeof(*block)); | |
114 | 43200 | memcpy(block + 2 * 8, pixels + 2 * line_size, 8 * sizeof(*block)); | |
115 | 43200 | memcpy(block + 5 * 8, pixels + 2 * line_size, 8 * sizeof(*block)); | |
116 | 43200 | memcpy(block + 3 * 8, pixels + 3 * line_size, 8 * sizeof(*block)); | |
117 | 43200 | memcpy(block + 4 * 8, pixels + 3 * line_size, 8 * sizeof(*block)); | |
118 | 43200 | } | |
119 | |||
120 | ✗ | static int dnxhd_10bit_dct_quantize_444(MpegEncContext *ctx, int16_t *block, | |
121 | int n, int qscale, int *overflow) | ||
122 | { | ||
123 | int i, j, level, last_non_zero, start_i; | ||
124 | const int *qmat; | ||
125 | ✗ | const uint8_t *scantable= ctx->intra_scantable.scantable; | |
126 | int bias; | ||
127 | ✗ | int max = 0; | |
128 | unsigned int threshold1, threshold2; | ||
129 | |||
130 | ✗ | ctx->fdsp.fdct(block); | |
131 | |||
132 | ✗ | block[0] = (block[0] + 2) >> 2; | |
133 | ✗ | start_i = 1; | |
134 | ✗ | last_non_zero = 0; | |
135 | ✗ | qmat = n < 4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale]; | |
136 | ✗ | bias= ctx->intra_quant_bias * (1 << (16 - 8)); | |
137 | ✗ | threshold1 = (1 << 16) - bias - 1; | |
138 | ✗ | threshold2 = (threshold1 << 1); | |
139 | |||
140 | ✗ | for (i = 63; i >= start_i; i--) { | |
141 | ✗ | j = scantable[i]; | |
142 | ✗ | level = block[j] * qmat[j]; | |
143 | |||
144 | ✗ | if (((unsigned)(level + threshold1)) > threshold2) { | |
145 | ✗ | last_non_zero = i; | |
146 | ✗ | break; | |
147 | } else{ | ||
148 | ✗ | block[j]=0; | |
149 | } | ||
150 | } | ||
151 | |||
152 | ✗ | for (i = start_i; i <= last_non_zero; i++) { | |
153 | ✗ | j = scantable[i]; | |
154 | ✗ | level = block[j] * qmat[j]; | |
155 | |||
156 | ✗ | if (((unsigned)(level + threshold1)) > threshold2) { | |
157 | ✗ | if (level > 0) { | |
158 | ✗ | level = (bias + level) >> 16; | |
159 | ✗ | block[j] = level; | |
160 | } else{ | ||
161 | ✗ | level = (bias - level) >> 16; | |
162 | ✗ | block[j] = -level; | |
163 | } | ||
164 | ✗ | max |= level; | |
165 | } else { | ||
166 | ✗ | block[j] = 0; | |
167 | } | ||
168 | } | ||
169 | ✗ | *overflow = ctx->max_qcoeff < max; //overflow might have happened | |
170 | |||
171 | /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ | ||
172 | ✗ | if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE) | |
173 | ✗ | ff_block_permute(block, ctx->idsp.idct_permutation, | |
174 | scantable, last_non_zero); | ||
175 | |||
176 | ✗ | return last_non_zero; | |
177 | } | ||
178 | |||
179 | 3945600 | static int dnxhd_10bit_dct_quantize(MpegEncContext *ctx, int16_t *block, | |
180 | int n, int qscale, int *overflow) | ||
181 | { | ||
182 | 3945600 | const uint8_t *scantable= ctx->intra_scantable.scantable; | |
183 |
2/2✓ Branch 0 taken 1972800 times.
✓ Branch 1 taken 1972800 times.
|
3945600 | const int *qmat = n<4 ? ctx->q_intra_matrix[qscale] : ctx->q_chroma_intra_matrix[qscale]; |
184 | 3945600 | int last_non_zero = 0; | |
185 | int i; | ||
186 | |||
187 | 3945600 | ctx->fdsp.fdct(block); | |
188 | |||
189 | // Divide by 4 with rounding, to compensate scaling of DCT coefficients | ||
190 | 3945600 | block[0] = (block[0] + 2) >> 2; | |
191 | |||
192 |
2/2✓ Branch 0 taken 248572800 times.
✓ Branch 1 taken 3945600 times.
|
252518400 | for (i = 1; i < 64; ++i) { |
193 | 248572800 | int j = scantable[i]; | |
194 | 248572800 | int sign = FF_SIGNBIT(block[j]); | |
195 | 248572800 | int level = (block[j] ^ sign) - sign; | |
196 | 248572800 | level = level * qmat[j] >> DNX10BIT_QMAT_SHIFT; | |
197 | 248572800 | block[j] = (level ^ sign) - sign; | |
198 |
2/2✓ Branch 0 taken 32824223 times.
✓ Branch 1 taken 215748577 times.
|
248572800 | if (level) |
199 | 32824223 | last_non_zero = i; | |
200 | } | ||
201 | |||
202 | /* we need this permutation so that we correct the IDCT, we only permute the !=0 elements */ | ||
203 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3945600 times.
|
3945600 | if (ctx->idsp.perm_type != FF_IDCT_PERM_NONE) |
204 | ✗ | ff_block_permute(block, ctx->idsp.idct_permutation, | |
205 | scantable, last_non_zero); | ||
206 | |||
207 | 3945600 | return last_non_zero; | |
208 | } | ||
209 | |||
210 | 73 | static av_cold int dnxhd_init_vlc(DNXHDEncContext *ctx) | |
211 | { | ||
212 | int i, j, level, run; | ||
213 | 73 | int max_level = 1 << (ctx->bit_depth + 2); | |
214 | |||
215 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | if (!FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_codes, max_level * 4) || |
216 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->orig_vlc_bits, max_level * 4) || |
217 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !(ctx->run_codes = av_mallocz(63 * 2)) || |
218 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | !(ctx->run_bits = av_mallocz(63))) |
219 | ✗ | return AVERROR(ENOMEM); | |
220 | 73 | ctx->vlc_codes = ctx->orig_vlc_codes + max_level * 2; | |
221 | 73 | ctx->vlc_bits = ctx->orig_vlc_bits + max_level * 2; | |
222 |
2/2✓ Branch 0 taken 192512 times.
✓ Branch 1 taken 73 times.
|
192585 | for (level = -max_level; level < max_level; level++) { |
223 |
2/2✓ Branch 0 taken 385024 times.
✓ Branch 1 taken 192512 times.
|
577536 | for (run = 0; run < 2; run++) { |
224 | 385024 | int index = level * (1 << 1) | run; | |
225 | 385024 | int sign, offset = 0, alevel = level; | |
226 | |||
227 | 385024 | MASK_ABS(sign, alevel); | |
228 |
2/2✓ Branch 0 taken 366190 times.
✓ Branch 1 taken 18834 times.
|
385024 | if (alevel > 64) { |
229 | 366190 | offset = (alevel - 1) >> 6; | |
230 | 366190 | alevel -= offset << 6; | |
231 | } | ||
232 |
2/2✓ Branch 0 taken 65136947 times.
✓ Branch 1 taken 73 times.
|
65137020 | for (j = 0; j < 257; j++) { |
233 |
4/4✓ Branch 0 taken 1197496 times.
✓ Branch 1 taken 63939451 times.
✓ Branch 2 taken 1163352 times.
✓ Branch 3 taken 34144 times.
|
65136947 | if (ctx->cid_table->ac_info[2*j+0] >> 1 == alevel && |
234 |
5/6✓ Branch 0 taken 549285 times.
✓ Branch 1 taken 614067 times.
✓ Branch 2 taken 549285 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 390917 times.
✓ Branch 5 taken 192512 times.
|
1197496 | (!offset || (ctx->cid_table->ac_info[2*j+1] & 1) && offset) && |
235 |
3/4✓ Branch 0 taken 192439 times.
✓ Branch 1 taken 198478 times.
✓ Branch 2 taken 192439 times.
✗ Branch 3 not taken.
|
390917 | (!run || (ctx->cid_table->ac_info[2*j+1] & 2) && run)) { |
236 | av_assert1(!ctx->vlc_codes[index]); | ||
237 |
2/2✓ Branch 0 taken 384878 times.
✓ Branch 1 taken 73 times.
|
384951 | if (alevel) { |
238 | 384878 | ctx->vlc_codes[index] = | |
239 | 384878 | (ctx->cid_table->ac_codes[j] << 1) | (sign & 1); | |
240 | 384878 | ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j] + 1; | |
241 | } else { | ||
242 | 73 | ctx->vlc_codes[index] = ctx->cid_table->ac_codes[j]; | |
243 | 73 | ctx->vlc_bits[index] = ctx->cid_table->ac_bits[j]; | |
244 | } | ||
245 | 384951 | break; | |
246 | } | ||
247 | } | ||
248 |
3/4✓ Branch 0 taken 384878 times.
✓ Branch 1 taken 146 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 384878 times.
|
385024 | av_assert0(!alevel || j < 257); |
249 |
2/2✓ Branch 0 taken 366190 times.
✓ Branch 1 taken 18834 times.
|
385024 | if (offset) { |
250 | 366190 | ctx->vlc_codes[index] = | |
251 | 366190 | (ctx->vlc_codes[index] << ctx->cid_table->index_bits) | offset; | |
252 | 366190 | ctx->vlc_bits[index] += ctx->cid_table->index_bits; | |
253 | } | ||
254 | } | ||
255 | } | ||
256 |
2/2✓ Branch 0 taken 4526 times.
✓ Branch 1 taken 73 times.
|
4599 | for (i = 0; i < 62; i++) { |
257 | 4526 | int run = ctx->cid_table->run[i]; | |
258 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4526 times.
|
4526 | av_assert0(run < 63); |
259 | 4526 | ctx->run_codes[run] = ctx->cid_table->run_codes[i]; | |
260 | 4526 | ctx->run_bits[run] = ctx->cid_table->run_bits[i]; | |
261 | } | ||
262 | 73 | return 0; | |
263 | } | ||
264 | |||
265 | 73 | static av_cold int dnxhd_init_qmat(DNXHDEncContext *ctx, int lbias, int cbias) | |
266 | { | ||
267 | // init first elem to 1 to avoid div by 0 in convert_matrix | ||
268 | 73 | uint16_t weight_matrix[64] = { 1, }; // convert_matrix needs uint16_t* | |
269 | int qscale, i; | ||
270 | 73 | const uint8_t *luma_weight_table = ctx->cid_table->luma_weight; | |
271 | 73 | const uint8_t *chroma_weight_table = ctx->cid_table->chroma_weight; | |
272 | |||
273 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | if (!FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l, ctx->m.avctx->qmax + 1) || |
274 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c, ctx->m.avctx->qmax + 1) || |
275 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_l16, ctx->m.avctx->qmax + 1) || |
276 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->qmatrix_c16, ctx->m.avctx->qmax + 1)) |
277 | ✗ | return AVERROR(ENOMEM); | |
278 | |||
279 |
2/2✓ Branch 0 taken 66 times.
✓ Branch 1 taken 7 times.
|
73 | if (ctx->bit_depth == 8) { |
280 |
2/2✓ Branch 0 taken 4158 times.
✓ Branch 1 taken 66 times.
|
4224 | for (i = 1; i < 64; i++) { |
281 | 4158 | int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]]; | |
282 | 4158 | weight_matrix[j] = ctx->cid_table->luma_weight[i]; | |
283 | } | ||
284 | 66 | ff_convert_matrix(&ctx->m, ctx->qmatrix_l, ctx->qmatrix_l16, | |
285 | weight_matrix, ctx->intra_quant_bias, 1, | ||
286 | 66 | ctx->m.avctx->qmax, 1); | |
287 |
2/2✓ Branch 0 taken 4158 times.
✓ Branch 1 taken 66 times.
|
4224 | for (i = 1; i < 64; i++) { |
288 | 4158 | int j = ctx->m.idsp.idct_permutation[ff_zigzag_direct[i]]; | |
289 | 4158 | weight_matrix[j] = ctx->cid_table->chroma_weight[i]; | |
290 | } | ||
291 | 66 | ff_convert_matrix(&ctx->m, ctx->qmatrix_c, ctx->qmatrix_c16, | |
292 | weight_matrix, ctx->intra_quant_bias, 1, | ||
293 | 66 | ctx->m.avctx->qmax, 1); | |
294 | |||
295 |
2/2✓ Branch 0 taken 42184 times.
✓ Branch 1 taken 66 times.
|
42250 | for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) { |
296 |
2/2✓ Branch 0 taken 2699776 times.
✓ Branch 1 taken 42184 times.
|
2741960 | for (i = 0; i < 64; i++) { |
297 | 2699776 | ctx->qmatrix_l[qscale][i] <<= 2; | |
298 | 2699776 | ctx->qmatrix_c[qscale][i] <<= 2; | |
299 | 2699776 | ctx->qmatrix_l16[qscale][0][i] <<= 2; | |
300 | 2699776 | ctx->qmatrix_l16[qscale][1][i] <<= 2; | |
301 | 2699776 | ctx->qmatrix_c16[qscale][0][i] <<= 2; | |
302 | 2699776 | ctx->qmatrix_c16[qscale][1][i] <<= 2; | |
303 | } | ||
304 | } | ||
305 | } else { | ||
306 | // 10-bit | ||
307 |
2/2✓ Branch 0 taken 56 times.
✓ Branch 1 taken 7 times.
|
63 | for (qscale = 1; qscale <= ctx->m.avctx->qmax; qscale++) { |
308 |
2/2✓ Branch 0 taken 3528 times.
✓ Branch 1 taken 56 times.
|
3584 | for (i = 1; i < 64; i++) { |
309 | 3528 | int j = ff_zigzag_direct[i]; | |
310 | |||
311 | /* The quantization formula from the VC-3 standard is: | ||
312 | * quantized = sign(block[i]) * floor(abs(block[i]/s) * p / | ||
313 | * (qscale * weight_table[i])) | ||
314 | * Where p is 32 for 8-bit samples and 8 for 10-bit ones. | ||
315 | * The s factor compensates scaling of DCT coefficients done by | ||
316 | * the DCT routines, and therefore is not present in standard. | ||
317 | * It's 8 for 8-bit samples and 4 for 10-bit ones. | ||
318 | * We want values of ctx->qtmatrix_l and ctx->qtmatrix_r to be: | ||
319 | * ((1 << DNX10BIT_QMAT_SHIFT) * (p / s)) / | ||
320 | * (qscale * weight_table[i]) | ||
321 | * For 10-bit samples, p / s == 2 */ | ||
322 | 3528 | ctx->qmatrix_l[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / | |
323 | 3528 | (qscale * luma_weight_table[i]); | |
324 | 3528 | ctx->qmatrix_c[qscale][j] = (1 << (DNX10BIT_QMAT_SHIFT + 1)) / | |
325 | 3528 | (qscale * chroma_weight_table[i]); | |
326 | } | ||
327 | } | ||
328 | } | ||
329 | |||
330 | 73 | ctx->m.q_chroma_intra_matrix16 = ctx->qmatrix_c16; | |
331 | 73 | ctx->m.q_chroma_intra_matrix = ctx->qmatrix_c; | |
332 | 73 | ctx->m.q_intra_matrix16 = ctx->qmatrix_l16; | |
333 | 73 | ctx->m.q_intra_matrix = ctx->qmatrix_l; | |
334 | |||
335 | 73 | return 0; | |
336 | } | ||
337 | |||
338 | 73 | static av_cold int dnxhd_init_rc(DNXHDEncContext *ctx) | |
339 | { | ||
340 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_rc, (ctx->m.avctx->qmax + 1) * ctx->m.mb_num)) |
341 | ✗ | return AVERROR(ENOMEM); | |
342 | |||
343 |
2/2✓ Branch 0 taken 58 times.
✓ Branch 1 taken 15 times.
|
73 | if (ctx->m.avctx->mb_decision != FF_MB_DECISION_RD) { |
344 |
1/2✓ Branch 1 taken 58 times.
✗ Branch 2 not taken.
|
58 | if (!FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp, ctx->m.mb_num) || |
345 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 58 times.
|
58 | !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_cmp_tmp, ctx->m.mb_num)) |
346 | ✗ | return AVERROR(ENOMEM); | |
347 | } | ||
348 | 73 | ctx->frame_bits = (ctx->coding_unit_size - | |
349 | 73 | ctx->data_offset - 4 - ctx->min_padding) * 8; | |
350 | 73 | ctx->qscale = 1; | |
351 | 73 | ctx->lambda = 2 << LAMBDA_FRAC_BITS; // qscale 2 | |
352 | 73 | return 0; | |
353 | } | ||
354 | |||
355 | 73 | static av_cold int dnxhd_encode_init(AVCodecContext *avctx) | |
356 | { | ||
357 | 73 | DNXHDEncContext *ctx = avctx->priv_data; | |
358 | int i, ret; | ||
359 | |||
360 |
2/3✓ Branch 0 taken 66 times.
✓ Branch 1 taken 7 times.
✗ Branch 2 not taken.
|
73 | switch (avctx->pix_fmt) { |
361 | 66 | case AV_PIX_FMT_YUV422P: | |
362 | 66 | ctx->bit_depth = 8; | |
363 | 66 | break; | |
364 | 7 | case AV_PIX_FMT_YUV422P10: | |
365 | case AV_PIX_FMT_YUV444P10: | ||
366 | case AV_PIX_FMT_GBRP10: | ||
367 | 7 | ctx->bit_depth = 10; | |
368 | 7 | break; | |
369 | } | ||
370 | |||
371 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
73 | if ((ctx->profile == AV_PROFILE_DNXHR_444 && (avctx->pix_fmt != AV_PIX_FMT_YUV444P10 && |
372 | ✗ | avctx->pix_fmt != AV_PIX_FMT_GBRP10)) || | |
373 |
2/4✓ Branch 0 taken 73 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
✗ Branch 3 not taken.
|
73 | (ctx->profile != AV_PROFILE_DNXHR_444 && (avctx->pix_fmt == AV_PIX_FMT_YUV444P10 || |
374 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | avctx->pix_fmt == AV_PIX_FMT_GBRP10))) { |
375 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
376 | "pixel format is incompatible with DNxHD profile\n"); | ||
377 | ✗ | return AVERROR(EINVAL); | |
378 | } | ||
379 | |||
380 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
73 | if (ctx->profile == AV_PROFILE_DNXHR_HQX && avctx->pix_fmt != AV_PIX_FMT_YUV422P10) { |
381 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
382 | "pixel format is incompatible with DNxHR HQX profile\n"); | ||
383 | ✗ | return AVERROR(EINVAL); | |
384 | } | ||
385 | |||
386 |
2/2✓ Branch 0 taken 61 times.
✓ Branch 1 taken 12 times.
|
73 | if ((ctx->profile == AV_PROFILE_DNXHR_LB || |
387 |
2/2✓ Branch 0 taken 53 times.
✓ Branch 1 taken 8 times.
|
61 | ctx->profile == AV_PROFILE_DNXHR_SQ || |
388 |
3/4✓ Branch 0 taken 20 times.
✓ Branch 1 taken 33 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 40 times.
|
73 | ctx->profile == AV_PROFILE_DNXHR_HQ) && avctx->pix_fmt != AV_PIX_FMT_YUV422P) { |
389 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
390 | "pixel format is incompatible with DNxHR LB/SQ/HQ profile\n"); | ||
391 | ✗ | return AVERROR(EINVAL); | |
392 | } | ||
393 | |||
394 | 73 | ctx->is_444 = ctx->profile == AV_PROFILE_DNXHR_444; | |
395 | 73 | avctx->profile = ctx->profile; | |
396 | 73 | ctx->cid = ff_dnxhd_find_cid(avctx, ctx->bit_depth); | |
397 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (!ctx->cid) { |
398 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
399 | "video parameters incompatible with DNxHD. Valid DNxHD profiles:\n"); | ||
400 | ✗ | ff_dnxhd_print_profiles(avctx, AV_LOG_ERROR); | |
401 | ✗ | return AVERROR(EINVAL); | |
402 | } | ||
403 | 73 | av_log(avctx, AV_LOG_DEBUG, "cid %d\n", ctx->cid); | |
404 | |||
405 |
3/4✓ Branch 0 taken 40 times.
✓ Branch 1 taken 33 times.
✓ Branch 2 taken 40 times.
✗ Branch 3 not taken.
|
73 | if (ctx->cid >= 1270 && ctx->cid <= 1274) |
406 | 40 | avctx->codec_tag = MKTAG('A','V','d','h'); | |
407 | |||
408 |
2/4✓ Branch 0 taken 73 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 73 times.
|
73 | if (avctx->width < 256 || avctx->height < 120) { |
409 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
410 | "Input dimensions too small, input must be at least 256x120\n"); | ||
411 | ✗ | return AVERROR(EINVAL); | |
412 | } | ||
413 | |||
414 | 73 | ctx->cid_table = ff_dnxhd_get_cid_table(ctx->cid); | |
415 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | av_assert0(ctx->cid_table); |
416 | |||
417 | 73 | ctx->m.avctx = avctx; | |
418 | 73 | ctx->m.mb_intra = 1; | |
419 | 73 | ctx->m.h263_aic = 1; | |
420 | |||
421 | 73 | avctx->bits_per_raw_sample = ctx->bit_depth; | |
422 | |||
423 | 73 | ff_blockdsp_init(&ctx->m.bdsp); | |
424 | 73 | ff_fdctdsp_init(&ctx->m.fdsp, avctx); | |
425 | 73 | ff_mpv_idct_init(&ctx->m); | |
426 | 73 | ff_mpegvideoencdsp_init(&ctx->m.mpvencdsp, avctx); | |
427 | 73 | ff_pixblockdsp_init(&ctx->m.pdsp, avctx); | |
428 | 73 | ff_dct_encode_init(&ctx->m); | |
429 | |||
430 |
2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 33 times.
|
73 | if (ctx->profile != AV_PROFILE_DNXHD) |
431 | 40 | ff_videodsp_init(&ctx->m.vdsp, ctx->bit_depth); | |
432 | |||
433 |
2/4✓ Branch 0 taken 73 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 73 times.
|
73 | if (ctx->is_444 || ctx->profile == AV_PROFILE_DNXHR_HQX) { |
434 | ✗ | ctx->m.dct_quantize = dnxhd_10bit_dct_quantize_444; | |
435 | ✗ | ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym; | |
436 | ✗ | ctx->block_width_l2 = 4; | |
437 |
2/2✓ Branch 0 taken 7 times.
✓ Branch 1 taken 66 times.
|
73 | } else if (ctx->bit_depth == 10) { |
438 | 7 | ctx->m.dct_quantize = dnxhd_10bit_dct_quantize; | |
439 | 7 | ctx->get_pixels_8x4_sym = dnxhd_10bit_get_pixels_8x4_sym; | |
440 | 7 | ctx->block_width_l2 = 4; | |
441 | } else { | ||
442 | 66 | ctx->get_pixels_8x4_sym = dnxhd_8bit_get_pixels_8x4_sym; | |
443 | 66 | ctx->block_width_l2 = 3; | |
444 | } | ||
445 | |||
446 | 73 | ff_dnxhdenc_init(ctx); | |
447 | |||
448 | 73 | ctx->m.mb_height = (avctx->height + 15) / 16; | |
449 | 73 | ctx->m.mb_width = (avctx->width + 15) / 16; | |
450 | |||
451 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 62 times.
|
73 | if (avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) { |
452 | 11 | ctx->interlaced = 1; | |
453 | 11 | ctx->m.mb_height /= 2; | |
454 | } | ||
455 | |||
456 |
3/4✓ Branch 0 taken 11 times.
✓ Branch 1 taken 62 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 11 times.
|
73 | if (ctx->interlaced && ctx->profile != AV_PROFILE_DNXHD) { |
457 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
458 | "Interlaced encoding is not supported for DNxHR profiles.\n"); | ||
459 | ✗ | return AVERROR(EINVAL); | |
460 | } | ||
461 | |||
462 | 73 | ctx->m.mb_num = ctx->m.mb_height * ctx->m.mb_width; | |
463 | |||
464 |
2/2✓ Branch 0 taken 40 times.
✓ Branch 1 taken 33 times.
|
73 | if (ctx->cid_table->frame_size == DNXHD_VARIABLE) { |
465 | 40 | ctx->frame_size = ff_dnxhd_get_hr_frame_size(ctx->cid, | |
466 | avctx->width, avctx->height); | ||
467 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 40 times.
|
40 | av_assert0(ctx->frame_size >= 0); |
468 | 40 | ctx->coding_unit_size = ctx->frame_size; | |
469 | } else { | ||
470 | 33 | ctx->frame_size = ctx->cid_table->frame_size; | |
471 | 33 | ctx->coding_unit_size = ctx->cid_table->coding_unit_size; | |
472 | } | ||
473 | |||
474 |
2/2✓ Branch 0 taken 12 times.
✓ Branch 1 taken 61 times.
|
73 | if (ctx->m.mb_height > 68) |
475 | 12 | ctx->data_offset = 0x170 + (ctx->m.mb_height << 2); | |
476 | else | ||
477 | 61 | ctx->data_offset = 0x280; | |
478 | |||
479 | // XXX tune lbias/cbias | ||
480 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | if ((ret = dnxhd_init_qmat(ctx, ctx->intra_quant_bias, 0)) < 0) |
481 | ✗ | return ret; | |
482 | |||
483 | /* Avid Nitris hardware decoder requires a minimum amount of padding | ||
484 | * in the coding unit payload */ | ||
485 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (ctx->nitris_compat) |
486 | ✗ | ctx->min_padding = 1600; | |
487 | |||
488 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | if ((ret = dnxhd_init_vlc(ctx)) < 0) |
489 | ✗ | return ret; | |
490 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | if ((ret = dnxhd_init_rc(ctx)) < 0) |
491 | ✗ | return ret; | |
492 | |||
493 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | if (!FF_ALLOCZ_TYPED_ARRAY(ctx->slice_size, ctx->m.mb_height) || |
494 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->slice_offs, ctx->m.mb_height) || |
495 |
1/2✓ Branch 1 taken 73 times.
✗ Branch 2 not taken.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_bits, ctx->m.mb_num) || |
496 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 73 times.
|
73 | !FF_ALLOCZ_TYPED_ARRAY(ctx->mb_qscale, ctx->m.mb_num)) |
497 | ✗ | return AVERROR(ENOMEM); | |
498 | |||
499 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (avctx->active_thread_type == FF_THREAD_SLICE) { |
500 | ✗ | if (avctx->thread_count > MAX_THREADS) { | |
501 | ✗ | av_log(avctx, AV_LOG_ERROR, "too many threads\n"); | |
502 | ✗ | return AVERROR(EINVAL); | |
503 | } | ||
504 | } | ||
505 | |||
506 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (avctx->qmax <= 1) { |
507 | ✗ | av_log(avctx, AV_LOG_ERROR, "qmax must be at least 2\n"); | |
508 | ✗ | return AVERROR(EINVAL); | |
509 | } | ||
510 | |||
511 | 73 | ctx->thread[0] = ctx; | |
512 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (avctx->active_thread_type == FF_THREAD_SLICE) { |
513 | ✗ | for (i = 1; i < avctx->thread_count; i++) { | |
514 | ✗ | ctx->thread[i] = av_memdup(ctx, sizeof(DNXHDEncContext)); | |
515 | ✗ | if (!ctx->thread[i]) | |
516 | ✗ | return AVERROR(ENOMEM); | |
517 | } | ||
518 | } | ||
519 | |||
520 | 73 | return 0; | |
521 | } | ||
522 | |||
523 | 380 | static int dnxhd_write_header(AVCodecContext *avctx, uint8_t *buf) | |
524 | { | ||
525 | 380 | DNXHDEncContext *ctx = avctx->priv_data; | |
526 | |||
527 | 380 | memset(buf, 0, ctx->data_offset); | |
528 | |||
529 | // * write prefix */ | ||
530 | 380 | AV_WB16(buf + 0x02, ctx->data_offset); | |
531 |
3/4✓ Branch 0 taken 200 times.
✓ Branch 1 taken 180 times.
✓ Branch 2 taken 200 times.
✗ Branch 3 not taken.
|
380 | if (ctx->cid >= 1270 && ctx->cid <= 1274) |
532 | 200 | buf[4] = 0x03; | |
533 | else | ||
534 | 180 | buf[4] = 0x01; | |
535 | |||
536 |
2/2✓ Branch 0 taken 110 times.
✓ Branch 1 taken 270 times.
|
380 | buf[5] = ctx->interlaced ? ctx->cur_field + 2 : 0x01; |
537 | 380 | buf[6] = 0x80; // crc flag off | |
538 | 380 | buf[7] = 0xa0; // reserved | |
539 | 380 | AV_WB16(buf + 0x18, avctx->height >> ctx->interlaced); // ALPF | |
540 | 380 | AV_WB16(buf + 0x1a, avctx->width); // SPL | |
541 | 380 | AV_WB16(buf + 0x1d, avctx->height >> ctx->interlaced); // NAL | |
542 | |||
543 |
2/2✓ Branch 0 taken 55 times.
✓ Branch 1 taken 325 times.
|
380 | buf[0x21] = ctx->bit_depth == 10 ? 0x58 : 0x38; |
544 | 380 | buf[0x22] = 0x88 + (ctx->interlaced << 2); | |
545 | 380 | AV_WB32(buf + 0x28, ctx->cid); // CID | |
546 |
2/2✓ Branch 0 taken 270 times.
✓ Branch 1 taken 110 times.
|
380 | buf[0x2c] = (!ctx->interlaced << 7) | (ctx->is_444 << 6) | (avctx->pix_fmt == AV_PIX_FMT_YUV444P10); |
547 | |||
548 | 380 | buf[0x5f] = 0x01; // UDL | |
549 | |||
550 | 380 | buf[0x167] = 0x02; // reserved | |
551 | 380 | AV_WB16(buf + 0x16a, ctx->m.mb_height * 4 + 4); // MSIPS | |
552 | 380 | AV_WB16(buf + 0x16c, ctx->m.mb_height); // Ns | |
553 | 380 | buf[0x16f] = 0x10; // reserved | |
554 | |||
555 | 380 | ctx->msip = buf + 0x170; | |
556 | 380 | return 0; | |
557 | } | ||
558 | |||
559 | 26918560 | static av_always_inline void dnxhd_encode_dc(PutBitContext *pb, DNXHDEncContext *ctx, int diff) | |
560 | { | ||
561 | int nbits; | ||
562 |
2/2✓ Branch 0 taken 12317800 times.
✓ Branch 1 taken 14600760 times.
|
26918560 | if (diff < 0) { |
563 | 12317800 | nbits = av_log2_16bit(-2 * diff); | |
564 | 12317800 | diff--; | |
565 | } else { | ||
566 | 14600760 | nbits = av_log2_16bit(2 * diff); | |
567 | } | ||
568 | 26918560 | put_bits(pb, ctx->cid_table->dc_bits[nbits] + nbits, | |
569 | 26918560 | (ctx->cid_table->dc_codes[nbits] << nbits) + | |
570 | 26918560 | av_zero_extend(diff, nbits)); | |
571 | 26918560 | } | |
572 | |||
573 | static av_always_inline | ||
574 | 26918560 | void dnxhd_encode_block(PutBitContext *pb, DNXHDEncContext *ctx, | |
575 | int16_t *block, int last_index, int n) | ||
576 | { | ||
577 | 26918560 | int last_non_zero = 0; | |
578 | int slevel, i, j; | ||
579 | |||
580 | 26918560 | dnxhd_encode_dc(pb, ctx, block[0] - ctx->m.last_dc[n]); | |
581 | 26918560 | ctx->m.last_dc[n] = block[0]; | |
582 | |||
583 |
2/2✓ Branch 0 taken 296815535 times.
✓ Branch 1 taken 26918560 times.
|
323734095 | for (i = 1; i <= last_index; i++) { |
584 | 296815535 | j = ctx->m.intra_scantable.permutated[i]; | |
585 | 296815535 | slevel = block[j]; | |
586 |
2/2✓ Branch 0 taken 111020901 times.
✓ Branch 1 taken 185794634 times.
|
296815535 | if (slevel) { |
587 | 111020901 | int run_level = i - last_non_zero - 1; | |
588 | 111020901 | int rlevel = slevel * (1 << 1) | !!run_level; | |
589 | 111020901 | put_bits(pb, ctx->vlc_bits[rlevel], ctx->vlc_codes[rlevel]); | |
590 |
2/2✓ Branch 0 taken 36001883 times.
✓ Branch 1 taken 75019018 times.
|
111020901 | if (run_level) |
591 | 36001883 | put_bits(pb, ctx->run_bits[run_level], | |
592 | 36001883 | ctx->run_codes[run_level]); | |
593 | 111020901 | last_non_zero = i; | |
594 | } | ||
595 | } | ||
596 | 26918560 | put_bits(pb, ctx->vlc_bits[0], ctx->vlc_codes[0]); // EOB | |
597 | 26918560 | } | |
598 | |||
599 | static av_always_inline | ||
600 | 3024000 | void dnxhd_unquantize_c(DNXHDEncContext *ctx, int16_t *block, int n, | |
601 | int qscale, int last_index) | ||
602 | { | ||
603 | const uint8_t *weight_matrix; | ||
604 | int level; | ||
605 | int i; | ||
606 | |||
607 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3024000 times.
|
3024000 | if (ctx->is_444) { |
608 | ✗ | weight_matrix = ((n % 6) < 2) ? ctx->cid_table->luma_weight | |
609 | ✗ | : ctx->cid_table->chroma_weight; | |
610 | } else { | ||
611 | 3024000 | weight_matrix = (n & 2) ? ctx->cid_table->chroma_weight | |
612 |
2/2✓ Branch 0 taken 1512000 times.
✓ Branch 1 taken 1512000 times.
|
3024000 | : ctx->cid_table->luma_weight; |
613 | } | ||
614 | |||
615 |
2/2✓ Branch 0 taken 32773315 times.
✓ Branch 1 taken 3024000 times.
|
35797315 | for (i = 1; i <= last_index; i++) { |
616 | 32773315 | int j = ctx->m.intra_scantable.permutated[i]; | |
617 | 32773315 | level = block[j]; | |
618 |
2/2✓ Branch 0 taken 16774641 times.
✓ Branch 1 taken 15998674 times.
|
32773315 | if (level) { |
619 |
2/2✓ Branch 0 taken 8458215 times.
✓ Branch 1 taken 8316426 times.
|
16774641 | if (level < 0) { |
620 | 8458215 | level = (1 - 2 * level) * qscale * weight_matrix[i]; | |
621 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8458215 times.
|
8458215 | if (ctx->bit_depth == 10) { |
622 | ✗ | if (weight_matrix[i] != 8) | |
623 | ✗ | level += 8; | |
624 | ✗ | level >>= 4; | |
625 | } else { | ||
626 |
2/2✓ Branch 0 taken 6479585 times.
✓ Branch 1 taken 1978630 times.
|
8458215 | if (weight_matrix[i] != 32) |
627 | 6479585 | level += 32; | |
628 | 8458215 | level >>= 6; | |
629 | } | ||
630 | 8458215 | level = -level; | |
631 | } else { | ||
632 | 8316426 | level = (2 * level + 1) * qscale * weight_matrix[i]; | |
633 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 8316426 times.
|
8316426 | if (ctx->bit_depth == 10) { |
634 | ✗ | if (weight_matrix[i] != 8) | |
635 | ✗ | level += 8; | |
636 | ✗ | level >>= 4; | |
637 | } else { | ||
638 |
2/2✓ Branch 0 taken 6813970 times.
✓ Branch 1 taken 1502456 times.
|
8316426 | if (weight_matrix[i] != 32) |
639 | 6813970 | level += 32; | |
640 | 8316426 | level >>= 6; | |
641 | } | ||
642 | } | ||
643 | 16774641 | block[j] = level; | |
644 | } | ||
645 | } | ||
646 | 3024000 | } | |
647 | |||
648 | 3024000 | static av_always_inline int dnxhd_ssd_block(int16_t *qblock, int16_t *block) | |
649 | { | ||
650 | 3024000 | int score = 0; | |
651 | int i; | ||
652 |
2/2✓ Branch 0 taken 193536000 times.
✓ Branch 1 taken 3024000 times.
|
196560000 | for (i = 0; i < 64; i++) |
653 | 193536000 | score += (block[i] - qblock[i]) * (block[i] - qblock[i]); | |
654 | 3024000 | return score; | |
655 | } | ||
656 | |||
657 | static av_always_inline | ||
658 | 51881432 | int dnxhd_calc_ac_bits(DNXHDEncContext *ctx, int16_t *block, int last_index) | |
659 | { | ||
660 | 51881432 | int last_non_zero = 0; | |
661 | 51881432 | int bits = 0; | |
662 | int i, j, level; | ||
663 |
2/2✓ Branch 0 taken 463138205 times.
✓ Branch 1 taken 51881432 times.
|
515019637 | for (i = 1; i <= last_index; i++) { |
664 | 463138205 | j = ctx->m.intra_scantable.permutated[i]; | |
665 | 463138205 | level = block[j]; | |
666 |
2/2✓ Branch 0 taken 191817206 times.
✓ Branch 1 taken 271320999 times.
|
463138205 | if (level) { |
667 | 191817206 | int run_level = i - last_non_zero - 1; | |
668 | 191817206 | bits += ctx->vlc_bits[level * (1 << 1) | | |
669 | 191817206 | !!run_level] + ctx->run_bits[run_level]; | |
670 | 191817206 | last_non_zero = i; | |
671 | } | ||
672 | } | ||
673 | 51881432 | return bits; | |
674 | } | ||
675 | |||
676 | static av_always_inline | ||
677 | 9849999 | void dnxhd_get_blocks(DNXHDEncContext *ctx, int mb_x, int mb_y) | |
678 | { | ||
679 | 9849999 | const int bs = ctx->block_width_l2; | |
680 | 9849999 | const int bw = 1 << bs; | |
681 | 9849999 | int dct_y_offset = ctx->dct_y_offset; | |
682 | 9849999 | int dct_uv_offset = ctx->dct_uv_offset; | |
683 | 9849999 | int linesize = ctx->m.linesize; | |
684 | 9849999 | int uvlinesize = ctx->m.uvlinesize; | |
685 | 9849999 | const uint8_t *ptr_y = ctx->thread[0]->src[0] + | |
686 | 9849999 | ((mb_y << 4) * ctx->m.linesize) + (mb_x << bs + 1); | |
687 | 9849999 | const uint8_t *ptr_u = ctx->thread[0]->src[1] + | |
688 | 9849999 | ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444); | |
689 | 9849999 | const uint8_t *ptr_v = ctx->thread[0]->src[2] + | |
690 | 9849999 | ((mb_y << 4) * ctx->m.uvlinesize) + (mb_x << bs + ctx->is_444); | |
691 | 9849999 | PixblockDSPContext *pdsp = &ctx->m.pdsp; | |
692 | 9849999 | VideoDSPContext *vdsp = &ctx->m.vdsp; | |
693 | |||
694 |
6/6✓ Branch 0 taken 9356799 times.
✓ Branch 1 taken 493200 times.
✓ Branch 2 taken 7207599 times.
✓ Branch 3 taken 2149200 times.
✓ Branch 4 taken 7203152 times.
✓ Branch 5 taken 4447 times.
|
9849999 | if (ctx->bit_depth != 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width || |
695 |
2/2✓ Branch 0 taken 18064 times.
✓ Branch 1 taken 7185088 times.
|
7203152 | (mb_y << 4) + 16 > ctx->m.avctx->height)) { |
696 | 22511 | int y_w = ctx->m.avctx->width - (mb_x << 4); | |
697 | 22511 | int y_h = ctx->m.avctx->height - (mb_y << 4); | |
698 | 22511 | int uv_w = (y_w + 1) / 2; | |
699 | 22511 | int uv_h = y_h; | |
700 | 22511 | linesize = 16; | |
701 | 22511 | uvlinesize = 8; | |
702 | |||
703 | 22511 | vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y, | |
704 | linesize, ctx->m.linesize, | ||
705 | linesize, 16, | ||
706 | 0, 0, y_w, y_h); | ||
707 | 22511 | vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u, | |
708 | uvlinesize, ctx->m.uvlinesize, | ||
709 | uvlinesize, 16, | ||
710 | 0, 0, uv_w, uv_h); | ||
711 | 22511 | vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v, | |
712 | uvlinesize, ctx->m.uvlinesize, | ||
713 | uvlinesize, 16, | ||
714 | 0, 0, uv_w, uv_h); | ||
715 | |||
716 | 22511 | dct_y_offset = bw * linesize; | |
717 | 22511 | dct_uv_offset = bw * uvlinesize; | |
718 | 22511 | ptr_y = &ctx->edge_buf_y[0]; | |
719 | 22511 | ptr_u = &ctx->edge_buf_uv[0][0]; | |
720 | 22511 | ptr_v = &ctx->edge_buf_uv[1][0]; | |
721 |
3/6✓ Branch 0 taken 493200 times.
✓ Branch 1 taken 9334288 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 493200 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
9827488 | } else if (ctx->bit_depth == 10 && vdsp->emulated_edge_mc && ((mb_x << 4) + 16 > ctx->m.avctx->width || |
722 | ✗ | (mb_y << 4) + 16 > ctx->m.avctx->height)) { | |
723 | ✗ | int y_w = ctx->m.avctx->width - (mb_x << 4); | |
724 | ✗ | int y_h = ctx->m.avctx->height - (mb_y << 4); | |
725 | ✗ | int uv_w = ctx->is_444 ? y_w : (y_w + 1) / 2; | |
726 | ✗ | int uv_h = y_h; | |
727 | ✗ | linesize = 32; | |
728 | ✗ | uvlinesize = 16 + 16 * ctx->is_444; | |
729 | |||
730 | ✗ | vdsp->emulated_edge_mc(&ctx->edge_buf_y[0], ptr_y, | |
731 | linesize, ctx->m.linesize, | ||
732 | linesize / 2, 16, | ||
733 | 0, 0, y_w, y_h); | ||
734 | ✗ | vdsp->emulated_edge_mc(&ctx->edge_buf_uv[0][0], ptr_u, | |
735 | uvlinesize, ctx->m.uvlinesize, | ||
736 | uvlinesize / 2, 16, | ||
737 | 0, 0, uv_w, uv_h); | ||
738 | ✗ | vdsp->emulated_edge_mc(&ctx->edge_buf_uv[1][0], ptr_v, | |
739 | uvlinesize, ctx->m.uvlinesize, | ||
740 | uvlinesize / 2, 16, | ||
741 | 0, 0, uv_w, uv_h); | ||
742 | |||
743 | ✗ | dct_y_offset = bw * linesize / 2; | |
744 | ✗ | dct_uv_offset = bw * uvlinesize / 2; | |
745 | ✗ | ptr_y = &ctx->edge_buf_y[0]; | |
746 | ✗ | ptr_u = &ctx->edge_buf_uv[0][0]; | |
747 | ✗ | ptr_v = &ctx->edge_buf_uv[1][0]; | |
748 | } | ||
749 | |||
750 |
1/2✓ Branch 0 taken 9849999 times.
✗ Branch 1 not taken.
|
9849999 | if (!ctx->is_444) { |
751 | 9849999 | pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize); | |
752 | 9849999 | pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize); | |
753 | 9849999 | pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize); | |
754 | 9849999 | pdsp->get_pixels(ctx->blocks[3], ptr_v, uvlinesize); | |
755 | |||
756 |
4/4✓ Branch 0 taken 131663 times.
✓ Branch 1 taken 9718336 times.
✓ Branch 2 taken 56560 times.
✓ Branch 3 taken 75103 times.
|
9849999 | if (mb_y + 1 == ctx->m.mb_height && ctx->m.avctx->height == 1080) { |
757 |
2/2✓ Branch 0 taken 35280 times.
✓ Branch 1 taken 21280 times.
|
56560 | if (ctx->interlaced) { |
758 | 35280 | ctx->get_pixels_8x4_sym(ctx->blocks[4], | |
759 | ptr_y + dct_y_offset, | ||
760 | linesize); | ||
761 | 35280 | ctx->get_pixels_8x4_sym(ctx->blocks[5], | |
762 | 35280 | ptr_y + dct_y_offset + bw, | |
763 | linesize); | ||
764 | 35280 | ctx->get_pixels_8x4_sym(ctx->blocks[6], | |
765 | ptr_u + dct_uv_offset, | ||
766 | uvlinesize); | ||
767 | 35280 | ctx->get_pixels_8x4_sym(ctx->blocks[7], | |
768 | ptr_v + dct_uv_offset, | ||
769 | uvlinesize); | ||
770 | } else { | ||
771 | 21280 | ctx->m.bdsp.clear_block(ctx->blocks[4]); | |
772 | 21280 | ctx->m.bdsp.clear_block(ctx->blocks[5]); | |
773 | 21280 | ctx->m.bdsp.clear_block(ctx->blocks[6]); | |
774 | 21280 | ctx->m.bdsp.clear_block(ctx->blocks[7]); | |
775 | } | ||
776 | } else { | ||
777 | 9793439 | pdsp->get_pixels(ctx->blocks[4], | |
778 | ptr_y + dct_y_offset, linesize); | ||
779 | 9793439 | pdsp->get_pixels(ctx->blocks[5], | |
780 | 9793439 | ptr_y + dct_y_offset + bw, linesize); | |
781 | 9793439 | pdsp->get_pixels(ctx->blocks[6], | |
782 | ptr_u + dct_uv_offset, uvlinesize); | ||
783 | 9793439 | pdsp->get_pixels(ctx->blocks[7], | |
784 | ptr_v + dct_uv_offset, uvlinesize); | ||
785 | } | ||
786 | } else { | ||
787 | ✗ | pdsp->get_pixels(ctx->blocks[0], ptr_y, linesize); | |
788 | ✗ | pdsp->get_pixels(ctx->blocks[1], ptr_y + bw, linesize); | |
789 | ✗ | pdsp->get_pixels(ctx->blocks[6], ptr_y + dct_y_offset, linesize); | |
790 | ✗ | pdsp->get_pixels(ctx->blocks[7], ptr_y + dct_y_offset + bw, linesize); | |
791 | |||
792 | ✗ | pdsp->get_pixels(ctx->blocks[2], ptr_u, uvlinesize); | |
793 | ✗ | pdsp->get_pixels(ctx->blocks[3], ptr_u + bw, uvlinesize); | |
794 | ✗ | pdsp->get_pixels(ctx->blocks[8], ptr_u + dct_uv_offset, uvlinesize); | |
795 | ✗ | pdsp->get_pixels(ctx->blocks[9], ptr_u + dct_uv_offset + bw, uvlinesize); | |
796 | |||
797 | ✗ | pdsp->get_pixels(ctx->blocks[4], ptr_v, uvlinesize); | |
798 | ✗ | pdsp->get_pixels(ctx->blocks[5], ptr_v + bw, uvlinesize); | |
799 | ✗ | pdsp->get_pixels(ctx->blocks[10], ptr_v + dct_uv_offset, uvlinesize); | |
800 | ✗ | pdsp->get_pixels(ctx->blocks[11], ptr_v + dct_uv_offset + bw, uvlinesize); | |
801 | } | ||
802 | 9849999 | } | |
803 | |||
804 | static av_always_inline | ||
805 | 78799992 | int dnxhd_switch_matrix(DNXHDEncContext *ctx, int i) | |
806 | { | ||
807 | int x; | ||
808 | |||
809 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 78799992 times.
|
78799992 | if (ctx->is_444) { |
810 | ✗ | x = (i >> 1) % 3; | |
811 | } else { | ||
812 | const static uint8_t component[8]={0,0,1,2,0,0,1,2}; | ||
813 | 78799992 | x = component[i]; | |
814 | } | ||
815 | 78799992 | return x; | |
816 | } | ||
817 | |||
818 | 41557 | static int dnxhd_calc_bits_thread(AVCodecContext *avctx, void *arg, | |
819 | int jobnr, int threadnr) | ||
820 | { | ||
821 | 41557 | DNXHDEncContext *ctx = avctx->priv_data; | |
822 | 41557 | int mb_y = jobnr, mb_x; | |
823 | 41557 | int qscale = ctx->qscale; | |
824 | 41557 | LOCAL_ALIGNED_16(int16_t, block, [64]); | |
825 | 41557 | ctx = ctx->thread[threadnr]; | |
826 | |||
827 | 41557 | ctx->m.last_dc[0] = | |
828 | 41557 | ctx->m.last_dc[1] = | |
829 | 41557 | ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2); | |
830 | |||
831 |
2/2✓ Branch 0 taken 6485179 times.
✓ Branch 1 taken 41557 times.
|
6526736 | for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) { |
832 | 6485179 | unsigned mb = mb_y * ctx->m.mb_width + mb_x; | |
833 | 6485179 | int ssd = 0; | |
834 | 6485179 | int ac_bits = 0; | |
835 | 6485179 | int dc_bits = 0; | |
836 | int i; | ||
837 | |||
838 | 6485179 | dnxhd_get_blocks(ctx, mb_x, mb_y); | |
839 | |||
840 |
2/2✓ Branch 0 taken 51881432 times.
✓ Branch 1 taken 6485179 times.
|
58366611 | for (i = 0; i < 8 + 4 * ctx->is_444; i++) { |
841 | 51881432 | int16_t *src_block = ctx->blocks[i]; | |
842 | int overflow, nbits, diff, last_index; | ||
843 | 51881432 | int n = dnxhd_switch_matrix(ctx, i); | |
844 | |||
845 | 51881432 | memcpy(block, src_block, 64 * sizeof(*block)); | |
846 | 51881432 | last_index = ctx->m.dct_quantize(&ctx->m, block, | |
847 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 51881432 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
51881432 | ctx->is_444 ? 4 * (n > 0): 4 & (2*i), |
848 | qscale, &overflow); | ||
849 | 51881432 | ac_bits += dnxhd_calc_ac_bits(ctx, block, last_index); | |
850 | |||
851 | 51881432 | diff = block[0] - ctx->m.last_dc[n]; | |
852 |
2/2✓ Branch 0 taken 23766663 times.
✓ Branch 1 taken 28114769 times.
|
51881432 | if (diff < 0) |
853 | 23766663 | nbits = av_log2_16bit(-2 * diff); | |
854 | else | ||
855 | 28114769 | nbits = av_log2_16bit(2 * diff); | |
856 | |||
857 | av_assert1(nbits < ctx->bit_depth + 4); | ||
858 | 51881432 | dc_bits += ctx->cid_table->dc_bits[nbits] + nbits; | |
859 | |||
860 | 51881432 | ctx->m.last_dc[n] = block[0]; | |
861 | |||
862 |
2/2✓ Branch 0 taken 3024000 times.
✓ Branch 1 taken 48857432 times.
|
51881432 | if (avctx->mb_decision == FF_MB_DECISION_RD || !RC_VARIANCE) { |
863 | 3024000 | dnxhd_unquantize_c(ctx, block, i, qscale, last_index); | |
864 | 3024000 | ctx->m.idsp.idct(block); | |
865 | 3024000 | ssd += dnxhd_ssd_block(block, src_block); | |
866 | } | ||
867 | } | ||
868 | 6485179 | ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].ssd = ssd; | |
869 | 6485179 | ctx->mb_rc[(qscale * ctx->m.mb_num) + mb].bits = ac_bits + dc_bits + 12 + | |
870 | 6485179 | (1 + ctx->is_444) * 8 * ctx->vlc_bits[0]; | |
871 | } | ||
872 | 41557 | return 0; | |
873 | } | ||
874 | |||
875 | 20765 | static int dnxhd_encode_thread(AVCodecContext *avctx, void *arg, | |
876 | int jobnr, int threadnr) | ||
877 | { | ||
878 | 20765 | DNXHDEncContext *ctx = avctx->priv_data; | |
879 | 20765 | PutBitContext pb0, *const pb = &pb0; | |
880 | 20765 | int mb_y = jobnr, mb_x; | |
881 | 20765 | ctx = ctx->thread[threadnr]; | |
882 | 20765 | init_put_bits(pb, (uint8_t *)arg + ctx->data_offset + ctx->slice_offs[jobnr], | |
883 | 20765 | ctx->slice_size[jobnr]); | |
884 | |||
885 | 20765 | ctx->m.last_dc[0] = | |
886 | 20765 | ctx->m.last_dc[1] = | |
887 | 20765 | ctx->m.last_dc[2] = 1 << (ctx->bit_depth + 2); | |
888 |
2/2✓ Branch 0 taken 3364820 times.
✓ Branch 1 taken 20765 times.
|
3385585 | for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) { |
889 | 3364820 | unsigned mb = mb_y * ctx->m.mb_width + mb_x; | |
890 | 3364820 | int qscale = ctx->mb_qscale[mb]; | |
891 | int i; | ||
892 | |||
893 | 3364820 | put_bits(pb, 11, qscale); | |
894 | 3364820 | put_bits(pb, 1, avctx->pix_fmt == AV_PIX_FMT_YUV444P10); | |
895 | |||
896 | 3364820 | dnxhd_get_blocks(ctx, mb_x, mb_y); | |
897 | |||
898 |
2/2✓ Branch 0 taken 26918560 times.
✓ Branch 1 taken 3364820 times.
|
30283380 | for (i = 0; i < 8 + 4 * ctx->is_444; i++) { |
899 | 26918560 | int16_t *block = ctx->blocks[i]; | |
900 | 26918560 | int overflow, n = dnxhd_switch_matrix(ctx, i); | |
901 | 26918560 | int last_index = ctx->m.dct_quantize(&ctx->m, block, | |
902 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 26918560 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
26918560 | ctx->is_444 ? (((i >> 1) % 3) < 1 ? 0 : 4): 4 & (2*i), |
903 | qscale, &overflow); | ||
904 | |||
905 | 26918560 | dnxhd_encode_block(pb, ctx, block, last_index, n); | |
906 | } | ||
907 | } | ||
908 | 20765 | flush_put_bits(pb); | |
909 | 20765 | memset(put_bits_ptr(pb), 0, put_bytes_left(pb, 0)); | |
910 | 20765 | return 0; | |
911 | } | ||
912 | |||
913 | 380 | static void dnxhd_setup_threads_slices(DNXHDEncContext *ctx) | |
914 | { | ||
915 | int mb_y, mb_x; | ||
916 | 380 | int offset = 0; | |
917 |
2/2✓ Branch 0 taken 20765 times.
✓ Branch 1 taken 380 times.
|
21145 | for (mb_y = 0; mb_y < ctx->m.mb_height; mb_y++) { |
918 | int thread_size; | ||
919 | 20765 | ctx->slice_offs[mb_y] = offset; | |
920 | 20765 | ctx->slice_size[mb_y] = 0; | |
921 |
2/2✓ Branch 0 taken 3364820 times.
✓ Branch 1 taken 20765 times.
|
3385585 | for (mb_x = 0; mb_x < ctx->m.mb_width; mb_x++) { |
922 | 3364820 | unsigned mb = mb_y * ctx->m.mb_width + mb_x; | |
923 | 3364820 | ctx->slice_size[mb_y] += ctx->mb_bits[mb]; | |
924 | } | ||
925 | 20765 | ctx->slice_size[mb_y] = (ctx->slice_size[mb_y] + 31U) & ~31U; | |
926 | 20765 | ctx->slice_size[mb_y] >>= 3; | |
927 | 20765 | thread_size = ctx->slice_size[mb_y]; | |
928 | 20765 | offset += thread_size; | |
929 | } | ||
930 | 380 | } | |
931 | |||
932 | 11520 | static int dnxhd_mb_var_thread(AVCodecContext *avctx, void *arg, | |
933 | int jobnr, int threadnr) | ||
934 | { | ||
935 | 11520 | DNXHDEncContext *ctx = avctx->priv_data; | |
936 | 11520 | int mb_y = jobnr, mb_x, x, y; | |
937 |
2/2✓ Branch 0 taken 220 times.
✓ Branch 1 taken 11300 times.
|
11740 | int partial_last_row = (mb_y == ctx->m.mb_height - 1) && |
938 |
2/2✓ Branch 0 taken 135 times.
✓ Branch 1 taken 85 times.
|
220 | ((avctx->height >> ctx->interlaced) & 0xF); |
939 | |||
940 | 11520 | ctx = ctx->thread[threadnr]; | |
941 |
2/2✓ Branch 0 taken 10955 times.
✓ Branch 1 taken 565 times.
|
11520 | if (ctx->bit_depth == 8) { |
942 | 10955 | const uint8_t *pix = ctx->thread[0]->src[0] + ((mb_y << 4) * ctx->m.linesize); | |
943 |
2/2✓ Branch 0 taken 1919700 times.
✓ Branch 1 taken 10955 times.
|
1930655 | for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x, pix += 16) { |
944 | 1919700 | unsigned mb = mb_y * ctx->m.mb_width + mb_x; | |
945 | int sum; | ||
946 | int varc; | ||
947 | |||
948 |
6/6✓ Branch 0 taken 1908265 times.
✓ Branch 1 taken 11435 times.
✓ Branch 2 taken 1907880 times.
✓ Branch 3 taken 385 times.
✓ Branch 4 taken 1901720 times.
✓ Branch 5 taken 6160 times.
|
1919700 | if (!partial_last_row && mb_x * 16 <= avctx->width - 16 && (avctx->width % 16) == 0) { |
949 | 1901720 | sum = ctx->m.mpvencdsp.pix_sum(pix, ctx->m.linesize); | |
950 | 1901720 | varc = ctx->m.mpvencdsp.pix_norm1(pix, ctx->m.linesize); | |
951 | } else { | ||
952 | 17980 | int bw = FFMIN(avctx->width - 16 * mb_x, 16); | |
953 | 17980 | int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16); | |
954 | 17980 | sum = varc = 0; | |
955 |
2/2✓ Branch 0 taken 226195 times.
✓ Branch 1 taken 17980 times.
|
244175 | for (y = 0; y < bh; y++) { |
956 |
2/2✓ Branch 0 taken 3573835 times.
✓ Branch 1 taken 226195 times.
|
3800030 | for (x = 0; x < bw; x++) { |
957 | 3573835 | uint8_t val = pix[x + y * ctx->m.linesize]; | |
958 | 3573835 | sum += val; | |
959 | 3573835 | varc += val * val; | |
960 | } | ||
961 | } | ||
962 | } | ||
963 | 1919700 | varc = (varc - (((unsigned) sum * sum) >> 8) + 128) >> 8; | |
964 | |||
965 | 1919700 | ctx->mb_cmp[mb].value = varc; | |
966 | 1919700 | ctx->mb_cmp[mb].mb = mb; | |
967 | } | ||
968 | } else { // 10-bit | ||
969 | 565 | const int linesize = ctx->m.linesize >> 1; | |
970 |
2/2✓ Branch 0 taken 58800 times.
✓ Branch 1 taken 565 times.
|
59365 | for (mb_x = 0; mb_x < ctx->m.mb_width; ++mb_x) { |
971 | 58800 | const uint16_t *pix = (const uint16_t *)ctx->thread[0]->src[0] + | |
972 | 58800 | ((mb_y << 4) * linesize) + (mb_x << 4); | |
973 | 58800 | unsigned mb = mb_y * ctx->m.mb_width + mb_x; | |
974 | 58800 | int sum = 0; | |
975 | 58800 | int sqsum = 0; | |
976 | 58800 | int bw = FFMIN(avctx->width - 16 * mb_x, 16); | |
977 | 58800 | int bh = FFMIN((avctx->height >> ctx->interlaced) - 16 * mb_y, 16); | |
978 | int mean, sqmean; | ||
979 | int i, j; | ||
980 | // Macroblocks are 16x16 pixels, unlike DCT blocks which are 8x8. | ||
981 |
2/2✓ Branch 0 taken 936000 times.
✓ Branch 1 taken 58800 times.
|
994800 | for (i = 0; i < bh; ++i) { |
982 |
2/2✓ Branch 0 taken 14976000 times.
✓ Branch 1 taken 936000 times.
|
15912000 | for (j = 0; j < bw; ++j) { |
983 | // Turn 16-bit pixels into 10-bit ones. | ||
984 | 14976000 | const int sample = (unsigned) pix[j] >> 6; | |
985 | 14976000 | sum += sample; | |
986 | 14976000 | sqsum += sample * sample; | |
987 | // 2^10 * 2^10 * 16 * 16 = 2^28, which is less than INT_MAX | ||
988 | } | ||
989 | 936000 | pix += linesize; | |
990 | } | ||
991 | 58800 | mean = sum >> 8; // 16*16 == 2^8 | |
992 | 58800 | sqmean = sqsum >> 8; | |
993 | 58800 | ctx->mb_cmp[mb].value = sqmean - mean * mean; | |
994 | 58800 | ctx->mb_cmp[mb].mb = mb; | |
995 | } | ||
996 | } | ||
997 | 11520 | return 0; | |
998 | } | ||
999 | |||
1000 | 15 | static int dnxhd_encode_rdo(AVCodecContext *avctx, DNXHDEncContext *ctx) | |
1001 | { | ||
1002 | int lambda, up_step, down_step; | ||
1003 | 15 | int last_lower = INT_MAX, last_higher = 0; | |
1004 | int x, y, q; | ||
1005 | |||
1006 |
2/2✓ Branch 0 taken 105 times.
✓ Branch 1 taken 15 times.
|
120 | for (q = 1; q < avctx->qmax; q++) { |
1007 | 105 | ctx->qscale = q; | |
1008 | 105 | avctx->execute2(avctx, dnxhd_calc_bits_thread, | |
1009 | NULL, NULL, ctx->m.mb_height); | ||
1010 | } | ||
1011 | 15 | up_step = down_step = 2 << LAMBDA_FRAC_BITS; | |
1012 | 15 | lambda = ctx->lambda; | |
1013 | |||
1014 | 70 | for (;;) { | |
1015 | 85 | int bits = 0; | |
1016 | 85 | int end = 0; | |
1017 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 80 times.
|
85 | if (lambda == last_higher) { |
1018 | 5 | lambda++; | |
1019 | 5 | end = 1; // need to set final qscales/bits | |
1020 | } | ||
1021 |
2/2✓ Branch 0 taken 3809 times.
✓ Branch 1 taken 53 times.
|
3862 | for (y = 0; y < ctx->m.mb_height; y++) { |
1022 |
2/2✓ Branch 0 taken 304720 times.
✓ Branch 1 taken 3809 times.
|
308529 | for (x = 0; x < ctx->m.mb_width; x++) { |
1023 | 304720 | unsigned min = UINT_MAX; | |
1024 | 304720 | int qscale = 1; | |
1025 | 304720 | int mb = y * ctx->m.mb_width + x; | |
1026 | 304720 | int rc = 0; | |
1027 |
2/2✓ Branch 0 taken 2133040 times.
✓ Branch 1 taken 304720 times.
|
2437760 | for (q = 1; q < avctx->qmax; q++) { |
1028 | 2133040 | int i = (q*ctx->m.mb_num) + mb; | |
1029 | 2133040 | unsigned score = ctx->mb_rc[i].bits * lambda + | |
1030 | 2133040 | ((unsigned) ctx->mb_rc[i].ssd << LAMBDA_FRAC_BITS); | |
1031 |
2/2✓ Branch 0 taken 493989 times.
✓ Branch 1 taken 1639051 times.
|
2133040 | if (score < min) { |
1032 | 493989 | min = score; | |
1033 | 493989 | qscale = q; | |
1034 | 493989 | rc = i; | |
1035 | } | ||
1036 | } | ||
1037 | 304720 | bits += ctx->mb_rc[rc].bits; | |
1038 | 304720 | ctx->mb_qscale[mb] = qscale; | |
1039 | 304720 | ctx->mb_bits[mb] = ctx->mb_rc[rc].bits; | |
1040 | } | ||
1041 | 3809 | bits = (bits + 31) & ~31; // padding | |
1042 |
2/2✓ Branch 0 taken 32 times.
✓ Branch 1 taken 3777 times.
|
3809 | if (bits > ctx->frame_bits) |
1043 | 32 | break; | |
1044 | } | ||
1045 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 80 times.
|
85 | if (end) { |
1046 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (bits > ctx->frame_bits) |
1047 | ✗ | return AVERROR(EINVAL); | |
1048 | 5 | break; | |
1049 | } | ||
1050 |
2/2✓ Branch 0 taken 48 times.
✓ Branch 1 taken 32 times.
|
80 | if (bits < ctx->frame_bits) { |
1051 | 48 | last_lower = FFMIN(lambda, last_lower); | |
1052 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 23 times.
|
48 | if (last_higher != 0) |
1053 | 25 | lambda = (lambda+last_higher)>>1; | |
1054 | else | ||
1055 | 23 | lambda -= down_step; | |
1056 | 48 | down_step = FFMIN((int64_t)down_step*5, INT_MAX); | |
1057 | 48 | up_step = 1<<LAMBDA_FRAC_BITS; | |
1058 | 48 | lambda = FFMAX(1, lambda); | |
1059 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 38 times.
|
48 | if (lambda == last_lower) |
1060 | 10 | break; | |
1061 | } else { | ||
1062 | 32 | last_higher = FFMAX(lambda, last_higher); | |
1063 |
1/2✓ Branch 0 taken 32 times.
✗ Branch 1 not taken.
|
32 | if (last_lower != INT_MAX) |
1064 | 32 | lambda = (lambda+last_lower)>>1; | |
1065 | ✗ | else if ((int64_t)lambda + up_step > INT_MAX) | |
1066 | ✗ | return AVERROR(EINVAL); | |
1067 | else | ||
1068 | ✗ | lambda += up_step; | |
1069 | 32 | up_step = FFMIN((int64_t)up_step*5, INT_MAX); | |
1070 | 32 | down_step = 1<<LAMBDA_FRAC_BITS; | |
1071 | } | ||
1072 | } | ||
1073 | 15 | ctx->lambda = lambda; | |
1074 | 15 | return 0; | |
1075 | } | ||
1076 | |||
1077 | 365 | static int dnxhd_find_qscale(DNXHDEncContext *ctx) | |
1078 | { | ||
1079 | 365 | int bits = 0; | |
1080 | 365 | int up_step = 1; | |
1081 | 365 | int down_step = 1; | |
1082 | 365 | int last_higher = 0; | |
1083 | 365 | int last_lower = INT_MAX; | |
1084 | int qscale; | ||
1085 | int x, y; | ||
1086 | |||
1087 | 365 | qscale = ctx->qscale; | |
1088 | for (;;) { | ||
1089 | 691 | bits = 0; | |
1090 | 691 | ctx->qscale = qscale; | |
1091 | // XXX avoid recalculating bits | ||
1092 | 691 | ctx->m.avctx->execute2(ctx->m.avctx, dnxhd_calc_bits_thread, | |
1093 | NULL, NULL, ctx->m.mb_height); | ||
1094 |
2/2✓ Branch 0 taken 34838 times.
✓ Branch 1 taken 393 times.
|
35231 | for (y = 0; y < ctx->m.mb_height; y++) { |
1095 |
2/2✓ Branch 0 taken 5760121 times.
✓ Branch 1 taken 34838 times.
|
5794959 | for (x = 0; x < ctx->m.mb_width; x++) |
1096 | 5760121 | bits += ctx->mb_rc[(qscale*ctx->m.mb_num) + (y*ctx->m.mb_width+x)].bits; | |
1097 | 34838 | bits = (bits+31)&~31; // padding | |
1098 |
2/2✓ Branch 0 taken 298 times.
✓ Branch 1 taken 34540 times.
|
34838 | if (bits > ctx->frame_bits) |
1099 | 298 | break; | |
1100 | } | ||
1101 |
2/2✓ Branch 0 taken 393 times.
✓ Branch 1 taken 298 times.
|
691 | if (bits < ctx->frame_bits) { |
1102 |
2/2✓ Branch 0 taken 145 times.
✓ Branch 1 taken 248 times.
|
393 | if (qscale == 1) |
1103 | 145 | return 1; | |
1104 |
2/2✓ Branch 0 taken 195 times.
✓ Branch 1 taken 53 times.
|
248 | if (last_higher == qscale - 1) { |
1105 | 195 | qscale = last_higher; | |
1106 | 195 | break; | |
1107 | } | ||
1108 | 53 | last_lower = FFMIN(qscale, last_lower); | |
1109 |
2/2✓ Branch 0 taken 38 times.
✓ Branch 1 taken 15 times.
|
53 | if (last_higher != 0) |
1110 | 38 | qscale = (qscale + last_higher) >> 1; | |
1111 | else | ||
1112 | 15 | qscale -= down_step++; | |
1113 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 53 times.
|
53 | if (qscale < 1) |
1114 | ✗ | qscale = 1; | |
1115 | 53 | up_step = 1; | |
1116 | } else { | ||
1117 |
2/2✓ Branch 0 taken 25 times.
✓ Branch 1 taken 273 times.
|
298 | if (last_lower == qscale + 1) |
1118 | 25 | break; | |
1119 | 273 | last_higher = FFMAX(qscale, last_higher); | |
1120 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 268 times.
|
273 | if (last_lower != INT_MAX) |
1121 | 5 | qscale = (qscale + last_lower) >> 1; | |
1122 | else | ||
1123 | 268 | qscale += up_step++; | |
1124 | 273 | down_step = 1; | |
1125 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 273 times.
|
273 | if (qscale >= ctx->m.avctx->qmax) |
1126 | ✗ | return AVERROR(EINVAL); | |
1127 | } | ||
1128 | } | ||
1129 | 220 | ctx->qscale = qscale; | |
1130 | 220 | return 0; | |
1131 | } | ||
1132 | |||
1133 | #define BUCKET_BITS 8 | ||
1134 | #define RADIX_PASSES 4 | ||
1135 | #define NBUCKETS (1 << BUCKET_BITS) | ||
1136 | |||
1137 | 11871000 | static inline int get_bucket(int value, int shift) | |
1138 | { | ||
1139 | 11871000 | value >>= shift; | |
1140 | 11871000 | value &= NBUCKETS - 1; | |
1141 | 11871000 | return NBUCKETS - 1 - value; | |
1142 | } | ||
1143 | |||
1144 | 220 | static void radix_count(const RCCMPEntry *data, int size, | |
1145 | int buckets[RADIX_PASSES][NBUCKETS]) | ||
1146 | { | ||
1147 | int i, j; | ||
1148 | 220 | memset(buckets, 0, sizeof(buckets[0][0]) * RADIX_PASSES * NBUCKETS); | |
1149 |
2/2✓ Branch 0 taken 1978500 times.
✓ Branch 1 taken 220 times.
|
1978720 | for (i = 0; i < size; i++) { |
1150 | 1978500 | int v = data[i].value; | |
1151 |
2/2✓ Branch 0 taken 7914000 times.
✓ Branch 1 taken 1978500 times.
|
9892500 | for (j = 0; j < RADIX_PASSES; j++) { |
1152 | 7914000 | buckets[j][get_bucket(v, 0)]++; | |
1153 | 7914000 | v >>= BUCKET_BITS; | |
1154 | } | ||
1155 | av_assert1(!v); | ||
1156 | } | ||
1157 |
2/2✓ Branch 0 taken 880 times.
✓ Branch 1 taken 220 times.
|
1100 | for (j = 0; j < RADIX_PASSES; j++) { |
1158 | 880 | int offset = size; | |
1159 |
2/2✓ Branch 0 taken 225280 times.
✓ Branch 1 taken 880 times.
|
226160 | for (i = NBUCKETS - 1; i >= 0; i--) |
1160 | 225280 | buckets[j][i] = offset -= buckets[j][i]; | |
1161 | av_assert1(!buckets[j][0]); | ||
1162 | } | ||
1163 | 220 | } | |
1164 | |||
1165 | 440 | static void radix_sort_pass(RCCMPEntry *dst, const RCCMPEntry *data, | |
1166 | int size, int buckets[NBUCKETS], int pass) | ||
1167 | { | ||
1168 | 440 | int shift = pass * BUCKET_BITS; | |
1169 | int i; | ||
1170 |
2/2✓ Branch 0 taken 3957000 times.
✓ Branch 1 taken 440 times.
|
3957440 | for (i = 0; i < size; i++) { |
1171 | 3957000 | int v = get_bucket(data[i].value, shift); | |
1172 | 3957000 | int pos = buckets[v]++; | |
1173 | 3957000 | dst[pos] = data[i]; | |
1174 | } | ||
1175 | 440 | } | |
1176 | |||
1177 | 220 | static void radix_sort(RCCMPEntry *data, RCCMPEntry *tmp, int size) | |
1178 | { | ||
1179 | int buckets[RADIX_PASSES][NBUCKETS]; | ||
1180 | 220 | radix_count(data, size, buckets); | |
1181 | 220 | radix_sort_pass(tmp, data, size, buckets[0], 0); | |
1182 | 220 | radix_sort_pass(data, tmp, size, buckets[1], 1); | |
1183 |
2/4✓ Branch 0 taken 220 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 220 times.
|
220 | if (buckets[2][NBUCKETS - 1] || buckets[3][NBUCKETS - 1]) { |
1184 | ✗ | radix_sort_pass(tmp, data, size, buckets[2], 2); | |
1185 | ✗ | radix_sort_pass(data, tmp, size, buckets[3], 3); | |
1186 | } | ||
1187 | 220 | } | |
1188 | |||
1189 | 365 | static int dnxhd_encode_fast(AVCodecContext *avctx, DNXHDEncContext *ctx) | |
1190 | { | ||
1191 | 365 | int max_bits = 0; | |
1192 | int ret, x, y; | ||
1193 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 365 times.
|
365 | if ((ret = dnxhd_find_qscale(ctx)) < 0) |
1194 | ✗ | return ret; | |
1195 |
2/2✓ Branch 0 taken 20090 times.
✓ Branch 1 taken 365 times.
|
20455 | for (y = 0; y < ctx->m.mb_height; y++) { |
1196 |
2/2✓ Branch 0 taken 3310820 times.
✓ Branch 1 taken 20090 times.
|
3330910 | for (x = 0; x < ctx->m.mb_width; x++) { |
1197 | 3310820 | int mb = y * ctx->m.mb_width + x; | |
1198 | 3310820 | int rc = (ctx->qscale * ctx->m.mb_num ) + mb; | |
1199 | int delta_bits; | ||
1200 | 3310820 | ctx->mb_qscale[mb] = ctx->qscale; | |
1201 | 3310820 | ctx->mb_bits[mb] = ctx->mb_rc[rc].bits; | |
1202 | 3310820 | max_bits += ctx->mb_rc[rc].bits; | |
1203 | if (!RC_VARIANCE) { | ||
1204 | delta_bits = ctx->mb_rc[rc].bits - | ||
1205 | ctx->mb_rc[rc + ctx->m.mb_num].bits; | ||
1206 | ctx->mb_cmp[mb].mb = mb; | ||
1207 | ctx->mb_cmp[mb].value = | ||
1208 | delta_bits ? ((ctx->mb_rc[rc].ssd - | ||
1209 | ctx->mb_rc[rc + ctx->m.mb_num].ssd) * 100) / | ||
1210 | delta_bits | ||
1211 | : INT_MIN; // avoid increasing qscale | ||
1212 | } | ||
1213 | } | ||
1214 | 20090 | max_bits += 31; // worst padding | |
1215 | } | ||
1216 |
2/2✓ Branch 0 taken 220 times.
✓ Branch 1 taken 145 times.
|
365 | if (!ret) { |
1217 | if (RC_VARIANCE) | ||
1218 | 220 | avctx->execute2(avctx, dnxhd_mb_var_thread, | |
1219 | NULL, NULL, ctx->m.mb_height); | ||
1220 | 220 | radix_sort(ctx->mb_cmp, ctx->mb_cmp_tmp, ctx->m.mb_num); | |
1221 | 222 | retry: | |
1222 |
4/4✓ Branch 0 taken 647231 times.
✓ Branch 1 taken 2 times.
✓ Branch 2 taken 647011 times.
✓ Branch 3 taken 220 times.
|
647233 | for (x = 0; x < ctx->m.mb_num && max_bits > ctx->frame_bits; x++) { |
1223 | 647011 | int mb = ctx->mb_cmp[x].mb; | |
1224 | 647011 | int rc = (ctx->qscale * ctx->m.mb_num ) + mb; | |
1225 | 647011 | max_bits -= ctx->mb_rc[rc].bits - | |
1226 | 647011 | ctx->mb_rc[rc + ctx->m.mb_num].bits; | |
1227 |
1/2✓ Branch 0 taken 647011 times.
✗ Branch 1 not taken.
|
647011 | if (ctx->mb_qscale[mb] < 255) |
1228 | 647011 | ctx->mb_qscale[mb]++; | |
1229 | 647011 | ctx->mb_bits[mb] = ctx->mb_rc[rc + ctx->m.mb_num].bits; | |
1230 | } | ||
1231 | |||
1232 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 220 times.
|
222 | if (max_bits > ctx->frame_bits) |
1233 | 2 | goto retry; | |
1234 | } | ||
1235 | 365 | return 0; | |
1236 | } | ||
1237 | |||
1238 | 325 | static void dnxhd_load_picture(DNXHDEncContext *ctx, const AVFrame *frame) | |
1239 | { | ||
1240 | int i; | ||
1241 | |||
1242 |
2/2✓ Branch 0 taken 325 times.
✓ Branch 1 taken 325 times.
|
650 | for (i = 0; i < ctx->m.avctx->thread_count; i++) { |
1243 | 325 | ctx->thread[i]->m.linesize = frame->linesize[0] << ctx->interlaced; | |
1244 | 325 | ctx->thread[i]->m.uvlinesize = frame->linesize[1] << ctx->interlaced; | |
1245 | 325 | ctx->thread[i]->dct_y_offset = ctx->m.linesize *8; | |
1246 | 325 | ctx->thread[i]->dct_uv_offset = ctx->m.uvlinesize*8; | |
1247 | } | ||
1248 | |||
1249 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 325 times.
|
325 | ctx->cur_field = (frame->flags & AV_FRAME_FLAG_INTERLACED) && |
1250 | ✗ | !(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST); | |
1251 | 325 | } | |
1252 | |||
1253 | 325 | static int dnxhd_encode_picture(AVCodecContext *avctx, AVPacket *pkt, | |
1254 | const AVFrame *frame, int *got_packet) | ||
1255 | { | ||
1256 | 325 | DNXHDEncContext *ctx = avctx->priv_data; | |
1257 | 325 | int first_field = 1; | |
1258 | int offset, i, ret; | ||
1259 | uint8_t *buf; | ||
1260 | |||
1261 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 325 times.
|
325 | if ((ret = ff_get_encode_buffer(avctx, pkt, ctx->frame_size, 0)) < 0) |
1262 | ✗ | return ret; | |
1263 | 325 | buf = pkt->data; | |
1264 | |||
1265 | 325 | dnxhd_load_picture(ctx, frame); | |
1266 | |||
1267 | 380 | encode_coding_unit: | |
1268 |
2/2✓ Branch 0 taken 1140 times.
✓ Branch 1 taken 380 times.
|
1520 | for (i = 0; i < 3; i++) { |
1269 | 1140 | ctx->src[i] = frame->data[i]; | |
1270 |
4/4✓ Branch 0 taken 330 times.
✓ Branch 1 taken 810 times.
✓ Branch 2 taken 165 times.
✓ Branch 3 taken 165 times.
|
1140 | if (ctx->interlaced && ctx->cur_field) |
1271 | 165 | ctx->src[i] += frame->linesize[i]; | |
1272 | } | ||
1273 | |||
1274 | 380 | dnxhd_write_header(avctx, buf); | |
1275 | |||
1276 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 365 times.
|
380 | if (avctx->mb_decision == FF_MB_DECISION_RD) |
1277 | 15 | ret = dnxhd_encode_rdo(avctx, ctx); | |
1278 | else | ||
1279 | 365 | ret = dnxhd_encode_fast(avctx, ctx); | |
1280 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 380 times.
|
380 | if (ret < 0) { |
1281 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
1282 | "picture could not fit ratecontrol constraints, increase qmax\n"); | ||
1283 | ✗ | return ret; | |
1284 | } | ||
1285 | |||
1286 | 380 | dnxhd_setup_threads_slices(ctx); | |
1287 | |||
1288 | 380 | offset = 0; | |
1289 |
2/2✓ Branch 0 taken 20765 times.
✓ Branch 1 taken 380 times.
|
21145 | for (i = 0; i < ctx->m.mb_height; i++) { |
1290 | 20765 | AV_WB32(ctx->msip + i * 4, offset); | |
1291 | 20765 | offset += ctx->slice_size[i]; | |
1292 | av_assert1(!(ctx->slice_size[i] & 3)); | ||
1293 | } | ||
1294 | |||
1295 | 380 | avctx->execute2(avctx, dnxhd_encode_thread, buf, NULL, ctx->m.mb_height); | |
1296 | |||
1297 | av_assert1(ctx->data_offset + offset + 4 <= ctx->coding_unit_size); | ||
1298 | 380 | memset(buf + ctx->data_offset + offset, 0, | |
1299 | 380 | ctx->coding_unit_size - 4 - offset - ctx->data_offset); | |
1300 | |||
1301 | 380 | AV_WB32(buf + ctx->coding_unit_size - 4, 0x600DC0DE); // EOF | |
1302 | |||
1303 |
4/4✓ Branch 0 taken 110 times.
✓ Branch 1 taken 270 times.
✓ Branch 2 taken 55 times.
✓ Branch 3 taken 55 times.
|
380 | if (ctx->interlaced && first_field) { |
1304 | 55 | first_field = 0; | |
1305 | 55 | ctx->cur_field ^= 1; | |
1306 | 55 | buf += ctx->coding_unit_size; | |
1307 | 55 | goto encode_coding_unit; | |
1308 | } | ||
1309 | |||
1310 | 325 | ff_side_data_set_encoder_stats(pkt, ctx->qscale * FF_QP2LAMBDA, NULL, 0, AV_PICTURE_TYPE_I); | |
1311 | |||
1312 | 325 | *got_packet = 1; | |
1313 | 325 | return 0; | |
1314 | } | ||
1315 | |||
1316 | 73 | static av_cold int dnxhd_encode_end(AVCodecContext *avctx) | |
1317 | { | ||
1318 | 73 | DNXHDEncContext *ctx = avctx->priv_data; | |
1319 | int i; | ||
1320 | |||
1321 | 73 | av_freep(&ctx->orig_vlc_codes); | |
1322 | 73 | av_freep(&ctx->orig_vlc_bits); | |
1323 | 73 | av_freep(&ctx->run_codes); | |
1324 | 73 | av_freep(&ctx->run_bits); | |
1325 | |||
1326 | 73 | av_freep(&ctx->mb_bits); | |
1327 | 73 | av_freep(&ctx->mb_qscale); | |
1328 | 73 | av_freep(&ctx->mb_rc); | |
1329 | 73 | av_freep(&ctx->mb_cmp); | |
1330 | 73 | av_freep(&ctx->mb_cmp_tmp); | |
1331 | 73 | av_freep(&ctx->slice_size); | |
1332 | 73 | av_freep(&ctx->slice_offs); | |
1333 | |||
1334 | 73 | av_freep(&ctx->qmatrix_c); | |
1335 | 73 | av_freep(&ctx->qmatrix_l); | |
1336 | 73 | av_freep(&ctx->qmatrix_c16); | |
1337 | 73 | av_freep(&ctx->qmatrix_l16); | |
1338 | |||
1339 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 73 times.
|
73 | if (ctx->thread[1]) { |
1340 | ✗ | for (i = 1; i < avctx->thread_count; i++) | |
1341 | ✗ | av_freep(&ctx->thread[i]); | |
1342 | } | ||
1343 | |||
1344 | 73 | return 0; | |
1345 | } | ||
1346 | |||
1347 | static const FFCodecDefault dnxhd_defaults[] = { | ||
1348 | { "qmax", "1024" }, /* Maximum quantization scale factor allowed for VC-3 */ | ||
1349 | { NULL }, | ||
1350 | }; | ||
1351 | |||
1352 | const FFCodec ff_dnxhd_encoder = { | ||
1353 | .p.name = "dnxhd", | ||
1354 | CODEC_LONG_NAME("VC3/DNxHD"), | ||
1355 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1356 | .p.id = AV_CODEC_ID_DNXHD, | ||
1357 | .p.capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS | | ||
1358 | AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE, | ||
1359 | .priv_data_size = sizeof(DNXHDEncContext), | ||
1360 | .init = dnxhd_encode_init, | ||
1361 | FF_CODEC_ENCODE_CB(dnxhd_encode_picture), | ||
1362 | .close = dnxhd_encode_end, | ||
1363 | .p.pix_fmts = (const enum AVPixelFormat[]) { | ||
1364 | AV_PIX_FMT_YUV422P, | ||
1365 | AV_PIX_FMT_YUV422P10, | ||
1366 | AV_PIX_FMT_YUV444P10, | ||
1367 | AV_PIX_FMT_GBRP10, | ||
1368 | AV_PIX_FMT_NONE | ||
1369 | }, | ||
1370 | .color_ranges = AVCOL_RANGE_MPEG, | ||
1371 | .p.priv_class = &dnxhd_class, | ||
1372 | .defaults = dnxhd_defaults, | ||
1373 | .p.profiles = NULL_IF_CONFIG_SMALL(ff_dnxhd_profiles), | ||
1374 | .caps_internal = FF_CODEC_CAP_INIT_CLEANUP, | ||
1375 | }; | ||
1376 | |||
1377 | 73 | void ff_dnxhdenc_init(DNXHDEncContext *ctx) | |
1378 | { | ||
1379 | #if ARCH_X86 | ||
1380 | 73 | ff_dnxhdenc_init_x86(ctx); | |
1381 | #endif | ||
1382 | 73 | } | |
1383 |