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