FFmpeg coverage

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