FFmpeg coverage


Directory: ../../../ffmpeg/
File: src/libavcodec/dvenc.c
Date: 2021-09-24 20:55:06
Exec Total Coverage
Lines: 454 507 89.5%
Branches: 222 276 80.4%

Line Branch Exec Source
1 /*
2 * DV encoder
3 * Copyright (c) 2003 Roman Shaposhnik
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * quant_deadzone code and fixes sponsored by NOA GmbH
22 */
23
24 /**
25 * @file
26 * DV encoder
27 */
28
29 #include "config.h"
30
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36 #include "libavutil/thread.h"
37
38 #include "avcodec.h"
39 #include "dv.h"
40 #include "dv_profile_internal.h"
41 #include "dv_tablegen.h"
42 #include "encode.h"
43 #include "fdctdsp.h"
44 #include "internal.h"
45 #include "mathops.h"
46 #include "me_cmp.h"
47 #include "pixblockdsp.h"
48 #include "put_bits.h"
49
50 22 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
51 {
52 22 DVVideoContext *s = avctx->priv_data;
53 FDCTDSPContext fdsp;
54 MECmpContext mecc;
55 PixblockDSPContext pdsp;
56 int ret;
57
58 22 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
59
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (!s->sys) {
60 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
61 "Valid DV profiles are:\n",
62 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
63 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
64 return AVERROR(EINVAL);
65 }
66
67 22 ret = ff_dv_init_dynamic_tables(s, s->sys);
68
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 22 times.
22 if (ret < 0) {
69 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
70 return ret;
71 }
72
73 22 memset(&fdsp,0, sizeof(fdsp));
74 22 memset(&mecc,0, sizeof(mecc));
75 22 memset(&pdsp,0, sizeof(pdsp));
76 22 ff_fdctdsp_init(&fdsp, avctx);
77 22 ff_me_cmp_init(&mecc, avctx);
78 22 ff_pixblockdsp_init(&pdsp, avctx);
79 22 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
80
81 22 s->get_pixels = pdsp.get_pixels;
82 22 s->ildct_cmp = mecc.ildct_cmp[5];
83
84 22 s->fdct[0] = fdsp.fdct;
85 22 s->fdct[1] = fdsp.fdct248;
86
87 #if !CONFIG_HARDCODED_TABLES
88 {
89 static AVOnce init_static_once = AV_ONCE_INIT;
90 22 ff_thread_once(&init_static_once, dv_vlc_map_tableinit);
91 }
92 #endif
93
94 22 return ff_dvvideo_init(avctx);
95 }
96
97 /* bit budget for AC only in 5 MBs */
98 static const int vs_total_ac_bits_hd = (68 * 6 + 52*2) * 5;
99 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
100 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
101
102 #if CONFIG_SMALL
103 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
104 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
105 uint32_t *vlc)
106 {
107 int size;
108 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
109 *vlc = dv_vlc_map[run][level].vlc | sign;
110 size = dv_vlc_map[run][level].size;
111 } else {
112 if (level < DV_VLC_MAP_LEV_SIZE) {
113 *vlc = dv_vlc_map[0][level].vlc | sign;
114 size = dv_vlc_map[0][level].size;
115 } else {
116 *vlc = 0xfe00 | (level << 1) | sign;
117 size = 16;
118 }
119 if (run) {
120 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
121 (0x1f80 | (run - 1))) << size;
122 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
123 }
124 }
125
126 return size;
127 }
128
129 static av_always_inline int dv_rl2vlc_size(int run, int level)
130 {
131 int size;
132
133 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
134 size = dv_vlc_map[run][level].size;
135 } else {
136 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
137 if (run)
138 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
139 }
140 return size;
141 }
142 #else
143 195207865 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
144 {
145 195207865 *vlc = dv_vlc_map[run][l].vlc | sign;
146 195207865 return dv_vlc_map[run][l].size;
147 }
148
149 620150551 static av_always_inline int dv_rl2vlc_size(int run, int l)
150 {
151 620150551 return dv_vlc_map[run][l].size;
152 }
153 #endif
154
155 typedef struct EncBlockInfo {
156 int area_q[4];
157 int bit_size[4];
158 int prev[5];
159 int cur_ac;
160 int cno;
161 int dct_mode;
162 int16_t mb[64];
163 uint8_t next[64];
164 uint8_t sign[64];
165 uint8_t partial_bit_count;
166 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
167 /* used by DV100 only: a copy of the weighted and classified but
168 not-yet-quantized AC coefficients. This is necessary for
169 re-quantizing at different steps. */
170 int16_t save[64];
171 int min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
172 } EncBlockInfo;
173
174 32303914 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
175 PutBitContext *pb_pool,
176 PutBitContext *pb_end)
177 {
178 int prev, bits_left;
179 32303914 PutBitContext *pb = pb_pool;
180 32303914 int size = bi->partial_bit_count;
181 32303914 uint32_t vlc = bi->partial_bit_buffer;
182
183 32303914 bi->partial_bit_count =
184 32303914 bi->partial_bit_buffer = 0;
185 for (;;) {
186 /* Find suitable storage space */
187
2/2
✓ Branch 1 taken 31504601 times.
✓ Branch 2 taken 237867865 times.
269372466 for (; size > (bits_left = put_bits_left(pb)); pb++) {
188
2/2
✓ Branch 0 taken 13321407 times.
✓ Branch 1 taken 18183194 times.
31504601 if (bits_left) {
189 13321407 size -= bits_left;
190 13321407 put_bits(pb, bits_left, vlc >> size);
191 13321407 vlc = av_mod_uintp2(vlc, size);
192 }
193
2/2
✓ Branch 0 taken 10973914 times.
✓ Branch 1 taken 20530687 times.
31504601 if (pb + 1 >= pb_end) {
194 10973914 bi->partial_bit_count = size;
195 10973914 bi->partial_bit_buffer = vlc;
196 10973914 return pb;
197 }
198 }
199
200 /* Store VLC */
201 237867865 put_bits(pb, size, vlc);
202
203
2/2
✓ Branch 0 taken 21330000 times.
✓ Branch 1 taken 216537865 times.
237867865 if (bi->cur_ac >= 64)
204 21330000 break;
205
206 /* Construct the next VLC */
207 216537865 prev = bi->cur_ac;
208 216537865 bi->cur_ac = bi->next[prev];
209
2/2
✓ Branch 0 taken 195207865 times.
✓ Branch 1 taken 21330000 times.
216537865 if (bi->cur_ac < 64) {
210 195207865 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
211 195207865 bi->sign[bi->cur_ac], &vlc);
212 } else {
213 21330000 size = 4;
214 21330000 vlc = 6; /* End Of Block stamp */
215 }
216 }
217 21330000 return pb;
218 }
219
220 7362000 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
221 ptrdiff_t linesize)
222 {
223
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7362000 times.
7362000 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
224 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
225 if (ps > 0) {
226 int is = s->ildct_cmp(NULL, data, NULL, linesize * 2, 4) +
227 s->ildct_cmp(NULL, data + linesize, NULL, linesize * 2, 4);
228 return ps > is;
229 }
230 }
231
232 7362000 return 0;
233 }
234
235 static const int dv_weight_bits = 18;
236 static const int dv_weight_88[64] = {
237 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
238 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
239 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
240 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
241 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
242 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
243 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
244 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
245 };
246 static const int dv_weight_248[64] = {
247 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
248 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
249 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
250 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
251 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
252 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
253 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
254 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
255 };
256
257 /* setting this to 1 results in a faster codec but
258 * somewhat lower image quality */
259 #define DV100_SACRIFICE_QUALITY_FOR_SPEED 1
260 #define DV100_ENABLE_FINER 1
261
262 /* pack combination of QNO and CNO into a single 8-bit value */
263 #define DV100_MAKE_QLEVEL(qno,cno) ((qno<<2) | (cno))
264 #define DV100_QLEVEL_QNO(qlevel) (qlevel>>2)
265 #define DV100_QLEVEL_CNO(qlevel) (qlevel&0x3)
266
267 #define DV100_NUM_QLEVELS 31
268
269 /* The quantization step is determined by a combination of QNO and
270 CNO. We refer to these combinations as "qlevels" (this term is our
271 own, it's not mentioned in the spec). We use CNO, a multiplier on
272 the quantization step, to "fill in the gaps" between quantization
273 steps associated with successive values of QNO. e.g. there is no
274 QNO for a quantization step of 10, but we can use QNO=5 CNO=1 to
275 get the same result. The table below encodes combinations of QNO
276 and CNO in order of increasing quantization coarseness. */
277 static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS] = {
278 DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
279 DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
280 DV100_MAKE_QLEVEL( 2,0), // 2*1= 2
281 DV100_MAKE_QLEVEL( 3,0), // 3*1= 3
282 DV100_MAKE_QLEVEL( 4,0), // 4*1= 4
283 DV100_MAKE_QLEVEL( 5,0), // 5*1= 5
284 DV100_MAKE_QLEVEL( 6,0), // 6*1= 6
285 DV100_MAKE_QLEVEL( 7,0), // 7*1= 7
286 DV100_MAKE_QLEVEL( 8,0), // 8*1= 8
287 DV100_MAKE_QLEVEL( 5,1), // 5*2=10
288 DV100_MAKE_QLEVEL( 6,1), // 6*2=12
289 DV100_MAKE_QLEVEL( 7,1), // 7*2=14
290 DV100_MAKE_QLEVEL( 9,0), // 16*1=16
291 DV100_MAKE_QLEVEL(10,0), // 18*1=18
292 DV100_MAKE_QLEVEL(11,0), // 20*1=20
293 DV100_MAKE_QLEVEL(12,0), // 22*1=22
294 DV100_MAKE_QLEVEL(13,0), // 24*1=24
295 DV100_MAKE_QLEVEL(14,0), // 28*1=28
296 DV100_MAKE_QLEVEL( 9,1), // 16*2=32
297 DV100_MAKE_QLEVEL(10,1), // 18*2=36
298 DV100_MAKE_QLEVEL(11,1), // 20*2=40
299 DV100_MAKE_QLEVEL(12,1), // 22*2=44
300 DV100_MAKE_QLEVEL(13,1), // 24*2=48
301 DV100_MAKE_QLEVEL(15,0), // 52*1=52
302 DV100_MAKE_QLEVEL(14,1), // 28*2=56
303 DV100_MAKE_QLEVEL( 9,2), // 16*4=64
304 DV100_MAKE_QLEVEL(10,2), // 18*4=72
305 DV100_MAKE_QLEVEL(11,2), // 20*4=80
306 DV100_MAKE_QLEVEL(12,2), // 22*4=88
307 DV100_MAKE_QLEVEL(13,2), // 24*4=96
308 // ...
309 DV100_MAKE_QLEVEL(15,3), // 52*8=416
310 };
311
312 static const int dv100_min_bias = 0;
313 static const int dv100_chroma_bias = 0;
314 static const int dv100_starting_qno = 1;
315
316 #if DV100_SACRIFICE_QUALITY_FOR_SPEED
317 static const int dv100_qlevel_inc = 4;
318 #else
319 static const int dv100_qlevel_inc = 1;
320 #endif
321
322 // 1/qstep, shifted up by 16 bits
323 static const int dv100_qstep_bits = 16;
324 static const int dv100_qstep_inv[16] = {
325 65536, 65536, 32768, 21845, 16384, 13107, 10923, 9362, 8192, 4096, 3641, 3277, 2979, 2731, 2341, 1260,
326 };
327
328 /* DV100 weights are pre-zigzagged, inverted and multiplied by 2^16
329 (in DV100 the AC components are divided by the spec weights) */
330 static const int dv_weight_1080[2][64] = {
331 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
332 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
333 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
334 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
335 25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
336 24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
337 21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
338 10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
339 { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
340 41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
341 40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
342 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
343 25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
344 12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
345 10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
346 5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
347 };
348
349 static const int dv_weight_720[2][64] = {
350 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
351 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
352 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
353 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
354 25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
355 16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
356 10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
357 5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
358 { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
359 29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
360 27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
361 13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
362 12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
363 6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
364 5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
365 2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
366 };
367
368 7290000 static av_always_inline int dv_set_class_number_sd(DVVideoContext *s,
369 int16_t *blk, EncBlockInfo *bi,
370 const uint8_t *zigzag_scan,
371 const int *weight, int bias)
372 {
373 int i, area;
374 /* We offer two different methods for class number assignment: the
375 * method suggested in SMPTE 314M Table 22, and an improved
376 * method. The SMPTE method is very conservative; it assigns class
377 * 3 (i.e. severe quantization) to any block where the largest AC
378 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
379 * consumption precisely, so there is no need to bias most blocks
380 * towards strongly lossy compression. Instead, we assign class 2
381 * to most blocks, and use class 3 only when strictly necessary
382 * (for blocks whose largest AC component exceeds 255). */
383
384 #if 0 /* SMPTE spec method */
385 static const int classes[] = { 12, 24, 36, 0xffff };
386 #else /* improved FFmpeg method */
387 static const int classes[] = { -1, -1, 255, 0xffff };
388 #endif
389 7290000 int max = classes[0];
390 7290000 int prev = 0;
391 7290000 const unsigned deadzone = s->quant_deadzone;
392 7290000 const unsigned threshold = 2 * deadzone;
393
394 7290000 bi->mb[0] = blk[0];
395
396
2/2
✓ Branch 0 taken 29160000 times.
✓ Branch 1 taken 7290000 times.
36450000 for (area = 0; area < 4; area++) {
397 29160000 bi->prev[area] = prev;
398 29160000 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
399
2/2
✓ Branch 0 taken 459270000 times.
✓ Branch 1 taken 29160000 times.
488430000 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
400 459270000 int level = blk[zigzag_scan[i]];
401
402
2/2
✓ Branch 0 taken 140566792 times.
✓ Branch 1 taken 318703208 times.
459270000 if (level + deadzone > threshold) {
403 140566792 bi->sign[i] = (level >> 31) & 1;
404 /* Weight it and shift down into range, adding for rounding.
405 * The extra division by a factor of 2^4 reverses the 8x
406 * expansion of the DCT AND the 2x doubling of the weights. */
407 140566792 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
408 140566792 (dv_weight_bits + 4);
409
2/2
✓ Branch 0 taken 16556689 times.
✓ Branch 1 taken 124010103 times.
140566792 if (!level)
410 16556689 continue;
411 124010103 bi->mb[i] = level;
412
2/2
✓ Branch 0 taken 10763673 times.
✓ Branch 1 taken 113246430 times.
124010103 if (level > max)
413 10763673 max = level;
414 124010103 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
415 124010103 bi->next[prev] = i;
416 124010103 prev = i;
417 }
418 }
419 }
420 7290000 bi->next[prev] = i;
421
2/2
✓ Branch 0 taken 12295219 times.
✓ Branch 1 taken 7290000 times.
19585219 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
422 ;
423
424 7290000 bi->cno += bias;
425
426
2/2
✓ Branch 0 taken 2431630 times.
✓ Branch 1 taken 4858370 times.
7290000 if (bi->cno >= 3) {
427 2431630 bi->cno = 3;
428 2431630 prev = 0;
429 2431630 i = bi->next[prev];
430
2/2
✓ Branch 0 taken 9726520 times.
✓ Branch 1 taken 2431630 times.
12158150 for (area = 0; area < 4; area++) {
431 9726520 bi->prev[area] = prev;
432 9726520 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
433
2/2
✓ Branch 0 taken 42987446 times.
✓ Branch 1 taken 9726520 times.
52713966 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
434 42987446 bi->mb[i] >>= 1;
435
436
2/2
✓ Branch 0 taken 25006098 times.
✓ Branch 1 taken 17981348 times.
42987446 if (bi->mb[i]) {
437 25006098 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
438 25006098 bi->next[prev] = i;
439 25006098 prev = i;
440 }
441 }
442 }
443 2431630 bi->next[prev] = i;
444 }
445
446 7290000 return bi->bit_size[0] + bi->bit_size[1] +
447 7290000 bi->bit_size[2] + bi->bit_size[3];
448 }
449
450 /* this function just copies the DCT coefficients and performs
451 the initial (non-)quantization. */
452 14040000 static inline void dv_set_class_number_hd(DVVideoContext *s,
453 int16_t *blk, EncBlockInfo *bi,
454 const uint8_t *zigzag_scan,
455 const int *weight, int bias)
456 {
457 14040000 int i, max = 0;
458
459 /* the first quantization (none at all) */
460 14040000 bi->area_q[0] = 1;
461
462 /* weigh AC components and store to save[] */
463 /* (i=0 is the DC component; we only include it to make the
464 number of loop iterations even, for future possible SIMD optimization) */
465
2/2
✓ Branch 0 taken 449280000 times.
✓ Branch 1 taken 14040000 times.
463320000 for (i = 0; i < 64; i += 2) {
466 int level0, level1;
467
468 /* get the AC component (in zig-zag order) */
469 449280000 level0 = blk[zigzag_scan[i+0]];
470 449280000 level1 = blk[zigzag_scan[i+1]];
471
472 /* extract sign and make it the lowest bit */
473 449280000 bi->sign[i+0] = (level0>>31)&1;
474 449280000 bi->sign[i+1] = (level1>>31)&1;
475
476 /* take absolute value of the level */
477 449280000 level0 = FFABS(level0);
478 449280000 level1 = FFABS(level1);
479
480 /* weigh it */
481 449280000 level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
482 449280000 level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
483
484 /* save unquantized value */
485 449280000 bi->save[i+0] = level0;
486 449280000 bi->save[i+1] = level1;
487
488 /* find max component */
489
2/2
✓ Branch 0 taken 14666809 times.
✓ Branch 1 taken 434613191 times.
449280000 if (bi->save[i+0] > max)
490 14666809 max = bi->save[i+0];
491
2/2
✓ Branch 0 taken 752557 times.
✓ Branch 1 taken 448527443 times.
449280000 if (bi->save[i+1] > max)
492 752557 max = bi->save[i+1];
493 }
494
495 /* copy DC component */
496 14040000 bi->mb[0] = blk[0];
497
498 /* the EOB code is 4 bits */
499 14040000 bi->bit_size[0] = 4;
500 14040000 bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
501
502 /* ensure that no AC coefficients are cut off */
503 14040000 bi->min_qlevel = ((max+256) >> 8);
504
505 14040000 bi->area_q[0] = 25; /* set to an "impossible" value */
506 14040000 bi->cno = 0;
507 14040000 }
508
509 21330000 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
510 DVVideoContext *s, int chroma)
511 {
512 21330000 LOCAL_ALIGNED_16(int16_t, blk, [64]);
513
514 21330000 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
515 21330000 bi->partial_bit_count = 0;
516 21330000 bi->partial_bit_buffer = 0;
517 21330000 bi->cur_ac = 0;
518
519
2/2
✓ Branch 0 taken 20196000 times.
✓ Branch 1 taken 1134000 times.
21330000 if (data) {
520
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 6156000 times.
20196000 if (DV_PROFILE_IS_HD(s->sys)) {
521 14040000 s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
522 14040000 s->fdct[0](blk);
523 } else {
524 6156000 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
525 6156000 s->get_pixels(blk, data, linesize);
526 6156000 s->fdct[bi->dct_mode](blk);
527 }
528 } else {
529 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
530 which is precisely what the spec calls for in the "dummy" blocks. */
531 1134000 memset(blk, 0, 64*sizeof(*blk));
532 1134000 bi->dct_mode = 0;
533 }
534
535
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 7290000 times.
21330000 if (DV_PROFILE_IS_HD(s->sys)) {
536 const int *weights;
537
2/2
✓ Branch 0 taken 9720000 times.
✓ Branch 1 taken 4320000 times.
14040000 if (s->sys->height == 1080) {
538 9720000 weights = dv_weight_1080[chroma];
539 } else { /* 720p */
540 4320000 weights = dv_weight_720[chroma];
541 }
542 14040000 dv_set_class_number_hd(s, blk, bi,
543 ff_zigzag_direct,
544 weights,
545 14040000 dv100_min_bias+chroma*dv100_chroma_bias);
546 } else {
547 14580000 dv_set_class_number_sd(s, blk, bi,
548
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7290000 times.
7290000 bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct,
549
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 7290000 times.
7290000 bi->dct_mode ? dv_weight_248 : dv_weight_88,
550 chroma);
551 }
552
553 21330000 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
554 }
555
556 /* DV100 quantize
557 Perform quantization by divinding the AC component by the qstep.
558 As an optimization we use a fixed-point integer multiply instead
559 of a divide. */
560 1903366584 static av_always_inline int dv100_quantize(int level, int qsinv)
561 {
562 /* this code is equivalent to */
563 /* return (level + qs/2) / qs; */
564
565 1903366584 return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
566
567 /* the extra +1024 is needed to make the rounding come out right. */
568
569 /* I (DJM) have verified that the results are exactly the same as
570 division for level 0-2048 at all QNOs. */
571 }
572
573 44252168 static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
574 {
575 int prev, k, qsinv;
576
577 44252168 int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
578 44252168 int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
579
580
4/4
✓ Branch 0 taken 18456472 times.
✓ Branch 1 taken 25795696 times.
✓ Branch 2 taken 14040000 times.
✓ Branch 3 taken 4416472 times.
44252168 if (b->area_q[0] == qno && b->cno == cno)
581 14040000 return b->bit_size[0];
582
583 30212168 qsinv = dv100_qstep_inv[qno];
584
585 /* record the new qstep */
586 30212168 b->area_q[0] = qno;
587 30212168 b->cno = cno;
588
589 /* reset encoded size (EOB = 4 bits) */
590 30212168 b->bit_size[0] = 4;
591
592 /* visit nonzero components and quantize */
593 30212168 prev = 0;
594
2/2
✓ Branch 0 taken 1903366584 times.
✓ Branch 1 taken 30212168 times.
1933578752 for (k = 1; k < 64; k++) {
595 /* quantize */
596 1903366584 int ac = dv100_quantize(b->save[k], qsinv) >> cno;
597
2/2
✓ Branch 0 taken 431284010 times.
✓ Branch 1 taken 1472082574 times.
1903366584 if (ac) {
598
2/2
✓ Branch 0 taken 770 times.
✓ Branch 1 taken 431283240 times.
431284010 if (ac > 255)
599 770 ac = 255;
600 431284010 b->mb[k] = ac;
601 431284010 b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
602 431284010 b->next[prev] = k;
603 431284010 prev = k;
604 }
605 }
606 30212168 b->next[prev] = k;
607
608 30212168 return b->bit_size[0];
609 }
610
611 351000 static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
612 {
613 EncBlockInfo *b;
614 int min_qlevel[5];
615 int qlevels[5];
616 int size[5];
617 int i, j;
618 /* cache block sizes at hypothetical qlevels */
619 351000 uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
620
621 /* get minimum qlevels */
622
2/2
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 351000 times.
2106000 for (i = 0; i < 5; i++) {
623 1755000 min_qlevel[i] = 1;
624
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 1755000 times.
15795000 for (j = 0; j < 8; j++) {
625
2/2
✓ Branch 0 taken 1834839 times.
✓ Branch 1 taken 12205161 times.
14040000 if (blks[8*i+j].min_qlevel > min_qlevel[i])
626 1834839 min_qlevel[i] = blks[8*i+j].min_qlevel;
627 }
628 }
629
630 /* initialize sizes */
631
2/2
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 351000 times.
2106000 for (i = 0; i < 5; i++) {
632 1755000 qlevels[i] = dv100_starting_qno;
633
2/2
✓ Branch 0 taken 1724635 times.
✓ Branch 1 taken 30365 times.
1755000 if (qlevels[i] < min_qlevel[i])
634 1724635 qlevels[i] = min_qlevel[i];
635
636 1755000 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
637 1755000 size[i] = 0;
638
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 1755000 times.
15795000 for (j = 0; j < 8; j++) {
639 14040000 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
640 14040000 size[i] += size_cache[8*i+j][qlevels[i]];
641 }
642 }
643
644 /* must we go coarser? */
645
2/2
✓ Branch 0 taken 264654 times.
✓ Branch 1 taken 86346 times.
351000 if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
646 264654 int largest = size[0] % 5; /* 'random' number */
647 264654 int qlevels_done = 0;
648
649 do {
650 /* find the macroblock with the lowest qlevel */
651
2/2
✓ Branch 0 taken 10107605 times.
✓ Branch 1 taken 2021521 times.
12129126 for (i = 0; i < 5; i++) {
652
2/2
✓ Branch 0 taken 321513 times.
✓ Branch 1 taken 9786092 times.
10107605 if (qlevels[i] < qlevels[largest])
653 321513 largest = i;
654 }
655
656 2021521 i = largest;
657 /* ensure that we don't enter infinite loop */
658 2021521 largest = (largest+1) % 5;
659
660 /* quantize a little bit more */
661 2021521 qlevels[i] += dv100_qlevel_inc;
662
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2021521 times.
2021521 if (qlevels[i] > DV100_NUM_QLEVELS-1) {
663 qlevels[i] = DV100_NUM_QLEVELS-1;
664 qlevels_done++;
665 }
666
667 2021521 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
668 2021521 size[i] = 0;
669
670 /* for each block */
671 2021521 b = &blks[8*i];
672
2/2
✓ Branch 0 taken 16172168 times.
✓ Branch 1 taken 2021521 times.
18193689 for (j = 0; j < 8; j++, b++) {
673 /* accumulate block size into macroblock */
674
1/2
✓ Branch 0 taken 16172168 times.
✗ Branch 1 not taken.
16172168 if(size_cache[8*i+j][qlevels[i]] == 0) {
675 /* it is safe to use actual_quantize() here because we only go from finer to coarser,
676 and it saves the final actual_quantize() down below */
677 16172168 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
678 }
679 16172168 size[i] += size_cache[8*i+j][qlevels[i]];
680 } /* for each block */
681
682
3/4
✓ Branch 0 taken 1756867 times.
✓ Branch 1 taken 264654 times.
✓ Branch 2 taken 1756867 times.
✗ Branch 3 not taken.
2021521 } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
683
684 // can we go finer?
685 86346 } else if (DV100_ENABLE_FINER &&
686
2/2
✓ Branch 0 taken 86340 times.
✓ Branch 1 taken 6 times.
86346 size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
687 int save_qlevel;
688 86340 int largest = size[0] % 5; /* 'random' number */
689
690 86340 while (qlevels[0] > min_qlevel[0] ||
691
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86340 times.
86340 qlevels[1] > min_qlevel[1] ||
692
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86340 times.
86340 qlevels[2] > min_qlevel[2] ||
693
2/4
✗ Branch 0 not taken.
✓ Branch 1 taken 86340 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 86340 times.
172680 qlevels[3] > min_qlevel[3] ||
694
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 86340 times.
86340 qlevels[4] > min_qlevel[4]) {
695
696 /* find the macroblock with the highest qlevel */
697 for (i = 0; i < 5; i++) {
698 if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
699 largest = i;
700 }
701
702 i = largest;
703
704 /* ensure that we don't enter infinite loop */
705 largest = (largest+1) % 5;
706
707 if (qlevels[i] <= min_qlevel[i]) {
708 /* can't unquantize any more */
709 continue;
710 }
711 /* quantize a little bit less */
712 save_qlevel = qlevels[i];
713 qlevels[i] -= dv100_qlevel_inc;
714 if (qlevels[i] < min_qlevel[i])
715 qlevels[i] = min_qlevel[i];
716
717 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
718
719 size[i] = 0;
720
721 /* for each block */
722 b = &blks[8*i];
723 for (j = 0; j < 8; j++, b++) {
724 /* accumulate block size into macroblock */
725 if(size_cache[8*i+j][qlevels[i]] == 0) {
726 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
727 }
728 size[i] += size_cache[8*i+j][qlevels[i]];
729 } /* for each block */
730
731 /* did we bust the limit? */
732 if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
733 /* go back down and exit */
734 qlevels[i] = save_qlevel;
735 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
736 break;
737 }
738 }
739 }
740
741 /* now do the actual quantization */
742
2/2
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 351000 times.
2106000 for (i = 0; i < 5; i++) {
743 /* for each block */
744 1755000 b = &blks[8*i];
745 1755000 size[i] = 0;
746
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 1755000 times.
15795000 for (j = 0; j < 8; j++, b++) {
747 /* accumulate block size into macroblock */
748 14040000 size[i] += dv100_actual_quantize(b, qlevels[i]);
749 } /* for each block */
750 }
751 351000 }
752
753 134212 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
754 {
755 int size[5];
756 int i, j, k, a, prev, a2;
757 EncBlockInfo *b;
758
759 134212 size[0] =
760 134212 size[1] =
761 134212 size[2] =
762 134212 size[3] =
763 134212 size[4] = 1 << 24;
764 do {
765 664729 b = blks;
766
2/2
✓ Branch 0 taken 3058770 times.
✓ Branch 1 taken 530517 times.
3589287 for (i = 0; i < 5; i++) {
767
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3058770 times.
3058770 if (!qnos[i])
768 continue;
769
770 3058770 qnos[i]--;
771 3058770 size[i] = 0;
772
2/2
✓ Branch 0 taken 18352620 times.
✓ Branch 1 taken 3058770 times.
21411390 for (j = 0; j < 6; j++, b++) {
773
2/2
✓ Branch 0 taken 73410480 times.
✓ Branch 1 taken 18352620 times.
91763100 for (a = 0; a < 4; a++) {
774
2/2
✓ Branch 0 taken 14357792 times.
✓ Branch 1 taken 59052688 times.
73410480 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
775 14357792 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
776 14357792 b->area_q[a]++;
777 14357792 prev = b->prev[a];
778 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
779
2/2
✓ Branch 0 taken 61238664 times.
✓ Branch 1 taken 14357792 times.
75596456 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
780 61238664 b->mb[k] >>= 1;
781
2/2
✓ Branch 0 taken 37590212 times.
✓ Branch 1 taken 23648452 times.
61238664 if (b->mb[k]) {
782 37590212 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
783 37590212 prev = k;
784 } else {
785
4/4
✓ Branch 0 taken 5340157 times.
✓ Branch 1 taken 18308295 times.
✓ Branch 2 taken 1130064 times.
✓ Branch 3 taken 4210093 times.
23648452 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
786
2/2
✓ Branch 0 taken 76 times.
✓ Branch 1 taken 1130064 times.
1130140 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
787 76 b->prev[a2] = prev;
788 av_assert2(a2 < 4);
789 av_assert2(b->mb[b->next[k]]);
790 1130064 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
791 1130064 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
792 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
793 1130064 b->prev[a2] = prev;
794 }
795 23648452 b->next[prev] = b->next[k];
796 }
797 }
798 14357792 b->prev[a + 1] = prev;
799 }
800 73410480 size[i] += b->bit_size[a];
801 }
802 }
803
2/2
✓ Branch 0 taken 134212 times.
✓ Branch 1 taken 2924558 times.
3058770 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
804 134212 return;
805 }
806
1/2
✓ Branch 0 taken 530517 times.
✗ Branch 1 not taken.
530517 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
807
808 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
809 b = blks;
810 size[0] = 5 * 6 * 4; // EOB
811 for (j = 0; j < 6 * 5; j++, b++) {
812 prev = b->prev[0];
813 for (k = b->next[prev]; k < 64; k = b->next[k]) {
814 if (b->mb[k] < a && b->mb[k] > -a) {
815 b->next[prev] = b->next[k];
816 } else {
817 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
818 prev = k;
819 }
820 }
821 }
822 }
823 }
824
825 /* update all cno values into the blocks, over-writing the old values without
826 touching anything else. (only used for DV100) */
827 351000 static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
828 {
829 uint8_t *data;
830 int mb_index, i;
831
832
2/2
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 351000 times.
2106000 for (mb_index = 0; mb_index < 5; mb_index++) {
833 1755000 data = dif + mb_index*80 + 4;
834
2/2
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 1755000 times.
15795000 for (i = 0; i < profile->bpm; i++) {
835 /* zero out the class number */
836 14040000 data[1] &= 0xCF;
837 /* add the new one */
838 14040000 data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
839
840 14040000 data += profile->block_sizes[i] >> 3;
841 }
842 }
843 351000 }
844
845 594000 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
846 {
847 594000 DVVideoContext *s = avctx->priv_data;
848 594000 DVwork_chunk *work_chunk = arg;
849 int mb_index, i, j;
850 int mb_x, mb_y, c_offset;
851 ptrdiff_t linesize, y_stride;
852 uint8_t *y_ptr;
853 uint8_t *dif, *p;
854 594000 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
855 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
856 PutBitContext pbs[5 * DV_MAX_BPM];
857 PutBitContext *pb;
858 EncBlockInfo *enc_blk;
859 594000 int vs_bit_size = 0;
860 int qnos[5];
861 594000 int *qnosp = &qnos[0];
862
863 594000 p = dif = &s->buf[work_chunk->buf_offset * 80];
864 594000 enc_blk = &enc_blks[0];
865
2/2
✓ Branch 0 taken 2970000 times.
✓ Branch 1 taken 594000 times.
3564000 for (mb_index = 0; mb_index < 5; mb_index++) {
866 2970000 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
867
868
2/2
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 1215000 times.
2970000 qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
869
870 2970000 y_ptr = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
871 2970000 linesize = s->frame->linesize[0];
872
873
4/4
✓ Branch 0 taken 1215000 times.
✓ Branch 1 taken 1755000 times.
✓ Branch 2 taken 1206000 times.
✓ Branch 3 taken 9000 times.
2970000 if (s->sys->height == 1080 && mb_y < 134)
874 1206000 enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
875 else
876 1764000 enc_blk->dct_mode = 0;
877
2/2
✓ Branch 0 taken 20790000 times.
✓ Branch 1 taken 2970000 times.
23760000 for (i = 1; i < 8; i++)
878 20790000 enc_blk[i].dct_mode = enc_blk->dct_mode;
879
880 /* initializing luminance blocks */
881
2/2
✓ Branch 0 taken 2605500 times.
✓ Branch 1 taken 364500 times.
2970000 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
882
4/4
✓ Branch 0 taken 283500 times.
✓ Branch 1 taken 2322000 times.
✓ Branch 2 taken 277200 times.
✓ Branch 3 taken 6300 times.
2605500 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
883
4/4
✓ Branch 0 taken 1755000 times.
✓ Branch 1 taken 844200 times.
✓ Branch 2 taken 1746000 times.
✓ Branch 3 taken 9000 times.
2599200 (s->sys->height >= 720 && mb_y != 134)) {
884
1/2
✓ Branch 0 taken 2116800 times.
✗ Branch 1 not taken.
2116800 y_stride = s->frame->linesize[0] * (1 << (3*!enc_blk->dct_mode));
885 } else {
886 853200 y_stride = 16;
887 }
888 2970000 y_ptr = s->frame->data[0] +
889 2970000 (mb_y * s->frame->linesize[0] + mb_x) * 8;
890 2970000 linesize = s->frame->linesize[0];
891
892
2/2
✓ Branch 0 taken 567000 times.
✓ Branch 1 taken 2403000 times.
2970000 if (s->sys->video_stype == 4) { /* SD 422 */
893 567000 vs_bit_size +=
894 567000 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
895 567000 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
896 1134000 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
897 567000 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
898 } else {
899 2403000 vs_bit_size +=
900 2403000 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
901 2403000 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
902 4806000 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
903 2403000 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
904 }
905 2970000 enc_blk += 4;
906
907 /* initializing chrominance blocks */
908 5940000 c_offset = ((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
909
2/2
✓ Branch 0 taken 283500 times.
✓ Branch 1 taken 2686500 times.
2970000 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) * 8;
910
2/2
✓ Branch 0 taken 5940000 times.
✓ Branch 1 taken 2970000 times.
8910000 for (j = 2; j; j--) {
911 5940000 uint8_t *c_ptr = s->frame->data[j] + c_offset;
912 5940000 linesize = s->frame->linesize[j];
913
3/4
✓ Branch 0 taken 5922000 times.
✓ Branch 1 taken 18000 times.
✓ Branch 2 taken 5922000 times.
✗ Branch 3 not taken.
5940000 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] * (1 << (3*!enc_blk->dct_mode)));
914
4/4
✓ Branch 0 taken 567000 times.
✓ Branch 1 taken 5373000 times.
✓ Branch 2 taken 12600 times.
✓ Branch 3 taken 554400 times.
5940000 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
915 uint8_t *d;
916 12600 uint8_t *b = scratch;
917
2/2
✓ Branch 0 taken 100800 times.
✓ Branch 1 taken 12600 times.
113400 for (i = 0; i < 8; i++) {
918 100800 d = c_ptr + linesize * 8;
919 100800 b[0] = c_ptr[0];
920 100800 b[1] = c_ptr[1];
921 100800 b[2] = c_ptr[2];
922 100800 b[3] = c_ptr[3];
923 100800 b[4] = d[0];
924 100800 b[5] = d[1];
925 100800 b[6] = d[2];
926 100800 b[7] = d[3];
927 100800 c_ptr += linesize;
928 100800 b += 16;
929 }
930 12600 c_ptr = scratch;
931 12600 linesize = 16;
932 }
933
934 5940000 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
935
2/2
✓ Branch 0 taken 3510000 times.
✓ Branch 1 taken 2430000 times.
5940000 if (s->sys->bpm == 8)
936 3510000 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
937 linesize, s, 1);
938 }
939 }
940
941
2/2
✓ Branch 0 taken 351000 times.
✓ Branch 1 taken 243000 times.
594000 if (DV_PROFILE_IS_HD(s->sys)) {
942 /* unconditional */
943 351000 dv_guess_qnos_hd(&enc_blks[0], qnosp);
944
2/2
✓ Branch 0 taken 134212 times.
✓ Branch 1 taken 108788 times.
243000 } else if (vs_total_ac_bits < vs_bit_size) {
945 134212 dv_guess_qnos(&enc_blks[0], qnosp);
946 }
947
948 /* DIF encoding process */
949
2/2
✓ Branch 0 taken 2970000 times.
✓ Branch 1 taken 594000 times.
3564000 for (j = 0; j < 5 * s->sys->bpm;) {
950 2970000 int start_mb = j;
951
952 2970000 p[3] = *qnosp++;
953 2970000 p += 4;
954
955 /* First pass over individual cells only */
956
2/2
✓ Branch 0 taken 21330000 times.
✓ Branch 1 taken 2970000 times.
24300000 for (i = 0; i < s->sys->bpm; i++, j++) {
957 21330000 int sz = s->sys->block_sizes[i] >> 3;
958
959 21330000 init_put_bits(&pbs[j], p, sz);
960 21330000 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
961
4/4
✓ Branch 0 taken 14040000 times.
✓ Branch 1 taken 7290000 times.
✓ Branch 2 taken 1755000 times.
✓ Branch 3 taken 12285000 times.
21330000 put_bits(&pbs[j], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
962 21330000 put_bits(&pbs[j], 2, enc_blks[j].cno);
963
964 21330000 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
965 21330000 p += sz;
966 }
967
968 /* Second pass over each MB space */
969 2970000 pb = &pbs[start_mb];
970
2/2
✓ Branch 0 taken 21330000 times.
✓ Branch 1 taken 2970000 times.
24300000 for (i = 0; i < s->sys->bpm; i++)
971
2/2
✓ Branch 0 taken 7190425 times.
✓ Branch 1 taken 14139575 times.
21330000 if (enc_blks[start_mb + i].partial_bit_count)
972 7190425 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
973 7190425 &pbs[start_mb + s->sys->bpm]);
974 }
975
976 /* Third and final pass over the whole video segment space */
977 594000 pb = &pbs[0];
978
2/2
✓ Branch 0 taken 21330000 times.
✓ Branch 1 taken 594000 times.
21924000 for (j = 0; j < 5 * s->sys->bpm; j++) {
979
2/2
✓ Branch 0 taken 3783489 times.
✓ Branch 1 taken 17546511 times.
21330000 if (enc_blks[j].partial_bit_count)
980 3783489 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
981
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 21330000 times.
21330000 if (enc_blks[j].partial_bit_count)
982 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
983 }
984
985
2/2
✓ Branch 0 taken 21330000 times.
✓ Branch 1 taken 594000 times.
21924000 for (j = 0; j < 5 * s->sys->bpm; j++) {
986 21330000 flush_put_bits(&pbs[j]);
987 21330000 memset(put_bits_ptr(&pbs[j]), 0xff, put_bytes_left(&pbs[j], 0));
988 }
989
990
2/2
✓ Branch 0 taken 351000 times.
✓ Branch 1 taken 243000 times.
594000 if (DV_PROFILE_IS_HD(s->sys))
991 351000 dv_revise_cnos(dif, enc_blks, s->sys);
992
993 594000 return 0;
994 }
995
996 304200 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
997 uint8_t *buf)
998 {
999 /*
1000 * Here's what SMPTE314M says about these two:
1001 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1002 * as track application IDs (APTn = 001, AP1n =
1003 * 001, AP2n = 001, AP3n = 001), if the source signal
1004 * comes from a digital VCR. If the signal source is
1005 * unknown, all bits for these data shall be set to 1.
1006 * (page 12) STYPE: STYPE defines a signal type of video signal
1007 * 00000b = 4:1:1 compression
1008 * 00100b = 4:2:2 compression
1009 * XXXXXX = Reserved
1010 * Now, I've got two problems with these statements:
1011 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1012 * It seems that for PAL as defined in IEC 61834 we have to set
1013 * APT to 000 and for SMPTE314M to 001.
1014 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1015 * compression scheme (if any).
1016 */
1017 304200 uint8_t aspect = 0;
1018 304200 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1019 int fs;
1020
1021
2/2
✓ Branch 0 taken 187200 times.
✓ Branch 1 taken 117000 times.
304200 if (c->avctx->height >= 720)
1022
3/4
✓ Branch 0 taken 124800 times.
✓ Branch 1 taken 62400 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 124800 times.
187200 fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1023 else
1024
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 117000 times.
117000 fs = c->frame->top_field_first ? 0x00 : 0x40;
1025
1026
2/2
✓ Branch 0 taken 117000 times.
✓ Branch 1 taken 187200 times.
304200 if (DV_PROFILE_IS_HD(c->sys) ||
1027 117000 (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1028
2/2
✓ Branch 0 taken 7800 times.
✓ Branch 1 taken 109200 times.
117000 c->avctx->width / c->avctx->height * 10) >= 17)
1029 /* HD formats are always 16:9 */
1030 195000 aspect = 0x02;
1031
1032 304200 buf[0] = (uint8_t) pack_id;
1033
3/4
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 140400 times.
✓ Branch 2 taken 140400 times.
✗ Branch 3 not taken.
304200 switch (pack_id) {
1034 23400 case dv_header525: /* I can't imagine why these two weren't defined as real */
1035 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1036 23400 buf[1] = 0xf8 | /* reserved -- always 1 */
1037 (apt & 0x07); /* APT: Track application ID */
1038 23400 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1039 23400 (0x0f << 3) | /* reserved -- always 1 */
1040 23400 (apt & 0x07); /* AP1: Audio application ID */
1041 23400 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1042 23400 (0x0f << 3) | /* reserved -- always 1 */
1043 23400 (apt & 0x07); /* AP2: Video application ID */
1044 23400 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1045 23400 (0x0f << 3) | /* reserved -- always 1 */
1046 23400 (apt & 0x07); /* AP3: Subcode application ID */
1047 23400 break;
1048 140400 case dv_video_source:
1049 140400 buf[1] = 0xff; /* reserved -- always 1 */
1050 140400 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1051 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1052 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1053 0xf; /* reserved -- always 1 */
1054 140400 buf[3] = (3 << 6) | /* reserved -- always 1 */
1055 140400 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1056 140400 c->sys->video_stype; /* signal type video compression */
1057 140400 buf[4] = 0xff; /* VISC: 0xff -- no information */
1058 140400 break;
1059 140400 case dv_video_control:
1060 140400 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1061 0x3f; /* reserved -- always 1 */
1062 140400 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1063 aspect;
1064 140400 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1065 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1066 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1067 140400 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1068 0xc; /* reserved -- always b1100 */
1069 140400 buf[4] = 0xff; /* reserved -- always 1 */
1070 140400 break;
1071 default:
1072 buf[1] =
1073 buf[2] =
1074 buf[3] =
1075 buf[4] = 0xff;
1076 }
1077 304200 return 5;
1078 }
1079
1080 3510000 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1081 uint8_t seq_num, uint8_t dif_num,
1082 uint8_t *buf)
1083 {
1084 3510000 int fsc = chan_num & 1;
1085 3510000 int fsp = 1 - (chan_num >> 1);
1086
1087 3510000 buf[0] = (uint8_t) t; /* Section type */
1088 3510000 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1089 3510000 (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1090 3510000 (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1091 3; /* reserved -- always 1 */
1092 3510000 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1093 3510000 return 3;
1094 }
1095
1096 280800 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1097 {
1098
3/4
✓ Branch 0 taken 234000 times.
✓ Branch 1 taken 46800 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 234000 times.
280800 if (syb_num == 0 || syb_num == 6) {
1099 46800 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1100 46800 (0 << 4) | /* AP3 (Subcode application ID) */
1101 0x0f; /* reserved -- always 1 */
1102
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 234000 times.
234000 } else if (syb_num == 11) {
1103 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1104 0x7f; /* reserved -- always 1 */
1105 } else {
1106 234000 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1107 234000 (0 << 4) | /* APT (Track application ID) */
1108 0x0f; /* reserved -- always 1 */
1109 }
1110 280800 buf[1] = 0xf0 | /* reserved -- always 1 */
1111 (syb_num & 0x0f); /* SSYB number 0 - 11 */
1112 280800 buf[2] = 0xff; /* reserved -- always 1 */
1113 280800 return 3;
1114 }
1115
1116 980 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
1117 {
1118 int chan, i, j, k;
1119 /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1120
4/4
✓ Branch 0 taken 200 times.
✓ Branch 1 taken 780 times.
✓ Branch 2 taken 100 times.
✓ Branch 3 taken 100 times.
980 int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
1121
1122
2/2
✓ Branch 0 taken 1955 times.
✓ Branch 1 taken 980 times.
2935 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1123
2/2
✓ Branch 0 taken 23400 times.
✓ Branch 1 taken 1955 times.
25355 for (i = 0; i < c->sys->difseg_size; i++) {
1124 23400 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1125
1126 /* DV header: 1DIF */
1127 23400 buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
1128
2/2
✓ Branch 0 taken 23100 times.
✓ Branch 1 taken 300 times.
23400 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
1129 c, buf);
1130 23400 buf += 72; /* unused bytes */
1131
1132 /* DV subcode: 2DIFs */
1133
2/2
✓ Branch 0 taken 46800 times.
✓ Branch 1 taken 23400 times.
70200 for (j = 0; j < 2; j++) {
1134 46800 buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
1135
2/2
✓ Branch 0 taken 280800 times.
✓ Branch 1 taken 46800 times.
327600 for (k = 0; k < 6; k++)
1136 280800 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1137 46800 buf += 29; /* unused bytes */
1138 }
1139
1140 /* DV VAUX: 3DIFS */
1141
2/2
✓ Branch 0 taken 70200 times.
✓ Branch 1 taken 23400 times.
93600 for (j = 0; j < 3; j++) {
1142 70200 buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
1143 70200 buf += dv_write_pack(dv_video_source, c, buf);
1144 70200 buf += dv_write_pack(dv_video_control, c, buf);
1145 70200 buf += 7 * 5;
1146 70200 buf += dv_write_pack(dv_video_source, c, buf);
1147 70200 buf += dv_write_pack(dv_video_control, c, buf);
1148 70200 buf += 4 * 5 + 2; /* unused bytes */
1149 }
1150
1151 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1152
2/2
✓ Branch 0 taken 3159000 times.
✓ Branch 1 taken 23400 times.
3182400 for (j = 0; j < 135; j++) {
1153
2/2
✓ Branch 0 taken 210600 times.
✓ Branch 1 taken 2948400 times.
3159000 if (j % 15 == 0) {
1154 210600 memset(buf, 0xff, 80);
1155 210600 buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
1156 210600 buf += 77; /* audio control & shuffled PCM audio */
1157 }
1158 3159000 buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
1159 3159000 buf += 77; /* 1 video macroblock: 1 bytes control
1160 * 4 * 14 bytes Y 8x8 data
1161 * 10 bytes Cr 8x8 data
1162 * 10 bytes Cb 8x8 data */
1163 }
1164 }
1165 }
1166 980 }
1167
1168 980 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1169 const AVFrame *frame, int *got_packet)
1170 {
1171 980 DVVideoContext *s = c->priv_data;
1172 int ret;
1173
1174
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 980 times.
980 if ((ret = ff_get_encode_buffer(c, pkt, s->sys->frame_size, 0)) < 0)
1175 return ret;
1176 /* Fixme: Only zero the part that is not overwritten later. */
1177 980 memset(pkt->data, 0, pkt->size);
1178
1179 980 c->pix_fmt = s->sys->pix_fmt;
1180 980 s->frame = frame;
1181 980 s->buf = pkt->data;
1182
1183 980 dv_format_frame(s, pkt->data);
1184
1185 980 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1186 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1187
1188 980 emms_c();
1189
1190 980 pkt->flags |= AV_PKT_FLAG_KEY;
1191 980 *got_packet = 1;
1192
1193 980 return 0;
1194 }
1195
1196 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1197 #define OFFSET(x) offsetof(DVVideoContext, x)
1198 static const AVOption dv_options[] = {
1199 { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1200 { NULL },
1201 };
1202
1203 static const AVClass dvvideo_encode_class = {
1204 .class_name = "dvvideo encoder",
1205 .item_name = av_default_item_name,
1206 .option = dv_options,
1207 .version = LIBAVUTIL_VERSION_INT,
1208 };
1209
1210 const AVCodec ff_dvvideo_encoder = {
1211 .name = "dvvideo",
1212 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1213 .type = AVMEDIA_TYPE_VIDEO,
1214 .id = AV_CODEC_ID_DVVIDEO,
1215 .capabilities = AV_CODEC_CAP_DR1 | AV_CODEC_CAP_FRAME_THREADS |
1216 AV_CODEC_CAP_SLICE_THREADS,
1217 .priv_data_size = sizeof(DVVideoContext),
1218 .init = dvvideo_encode_init,
1219 .encode2 = dvvideo_encode_frame,
1220 .pix_fmts = (const enum AVPixelFormat[]) {
1221 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
1222 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1223 },
1224 .priv_class = &dvvideo_encode_class,
1225 .caps_internal = FF_CODEC_CAP_INIT_THREADSAFE,
1226 };
1227