3 * Copyright (c) 2003 Roman Shaposhnik
5 * This file is part of FFmpeg.
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.
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.
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
21 * quant_deadzone code and fixes sponsored by NOA GmbH
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"
39 #include "dv_profile_internal.h"
40 #include "dv_tablegen.h"
45 #include "pixblockdsp.h"
48 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
50 DVVideoContext *s = avctx->priv_data;
53 PixblockDSPContext pdsp;
56 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
58 av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
59 "Valid DV profiles are:\n",
60 avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
61 ff_dv_print_profiles(avctx, AV_LOG_ERROR);
62 return AVERROR(EINVAL);
65 ret = ff_dv_init_dynamic_tables(s, s->sys);
67 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
71 dv_vlc_map_tableinit();
73 memset(&fdsp,0, sizeof(fdsp));
74 memset(&mecc,0, sizeof(mecc));
75 memset(&pdsp,0, sizeof(pdsp));
76 ff_fdctdsp_init(&fdsp, avctx);
77 ff_me_cmp_init(&mecc, avctx);
78 ff_pixblockdsp_init(&pdsp, avctx);
79 ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
81 s->get_pixels = pdsp.get_pixels;
82 s->ildct_cmp = mecc.ildct_cmp[5];
84 s->fdct[0] = fdsp.fdct;
85 s->fdct[1] = fdsp.fdct248;
87 return ff_dvvideo_init(avctx);
90 /* bit budget for AC only in 5 MBs */
91 static const int vs_total_ac_bits_hd = (68 * 6 + 52*2) * 5;
92 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
93 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
96 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
97 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
101 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
102 *vlc = dv_vlc_map[run][level].vlc | sign;
103 size = dv_vlc_map[run][level].size;
105 if (level < DV_VLC_MAP_LEV_SIZE) {
106 *vlc = dv_vlc_map[0][level].vlc | sign;
107 size = dv_vlc_map[0][level].size;
109 *vlc = 0xfe00 | (level << 1) | sign;
113 *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
114 (0x1f80 | (run - 1))) << size;
115 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
122 static av_always_inline int dv_rl2vlc_size(int run, int level)
126 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
127 size = dv_vlc_map[run][level].size;
129 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
131 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
136 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
138 *vlc = dv_vlc_map[run][l].vlc | sign;
139 return dv_vlc_map[run][l].size;
142 static av_always_inline int dv_rl2vlc_size(int run, int l)
144 return dv_vlc_map[run][l].size;
148 typedef struct EncBlockInfo {
158 uint8_t partial_bit_count;
159 uint32_t partial_bit_buffer; /* we can't use uint16_t here */
160 /* used by DV100 only: a copy of the weighted and classified but
161 not-yet-quantized AC coefficients. This is necessary for
162 re-quantizing at different steps. */
164 int min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
167 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
168 PutBitContext *pb_pool,
169 PutBitContext *pb_end)
172 PutBitContext *pb = pb_pool;
173 int size = bi->partial_bit_count;
174 uint32_t vlc = bi->partial_bit_buffer;
176 bi->partial_bit_count =
177 bi->partial_bit_buffer = 0;
179 /* Find suitable storage space */
180 for (; size > (bits_left = put_bits_left(pb)); pb++) {
183 put_bits(pb, bits_left, vlc >> size);
184 vlc = av_mod_uintp2(vlc, size);
186 if (pb + 1 >= pb_end) {
187 bi->partial_bit_count = size;
188 bi->partial_bit_buffer = vlc;
194 put_bits(pb, size, vlc);
196 if (bi->cur_ac >= 64)
199 /* Construct the next VLC */
201 bi->cur_ac = bi->next[prev];
202 if (bi->cur_ac < 64) {
203 size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
204 bi->sign[bi->cur_ac], &vlc);
207 vlc = 6; /* End Of Block stamp */
213 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
216 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
217 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
219 int is = s->ildct_cmp(NULL, data, NULL, linesize * 2, 4) +
220 s->ildct_cmp(NULL, data + linesize, NULL, linesize * 2, 4);
228 static const int dv_weight_bits = 18;
229 static const int dv_weight_88[64] = {
230 131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
231 237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
232 224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
233 212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
234 206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
235 200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
236 174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
237 170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
239 static const int dv_weight_248[64] = {
240 131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
241 237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
242 223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
243 211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
244 211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
245 200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
246 185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
247 170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
250 /* setting this to 1 results in a faster codec but
251 * somewhat lower image quality */
252 #define DV100_SACRIFICE_QUALITY_FOR_SPEED 1
253 #define DV100_ENABLE_FINER 1
255 /* pack combination of QNO and CNO into a single 8-bit value */
256 #define DV100_MAKE_QLEVEL(qno,cno) ((qno<<2) | (cno))
257 #define DV100_QLEVEL_QNO(qlevel) (qlevel>>2)
258 #define DV100_QLEVEL_CNO(qlevel) (qlevel&0x3)
260 #define DV100_NUM_QLEVELS 31
262 /* The quantization step is determined by a combination of QNO and
263 CNO. We refer to these combinations as "qlevels" (this term is our
264 own, it's not mentioned in the spec). We use CNO, a multiplier on
265 the quantization step, to "fill in the gaps" between quantization
266 steps associated with successive values of QNO. e.g. there is no
267 QNO for a quantization step of 10, but we can use QNO=5 CNO=1 to
268 get the same result. The table below encodes combinations of QNO
269 and CNO in order of increasing quantization coarseness. */
270 static const uint8_t dv100_qlevels[DV100_NUM_QLEVELS] = {
271 DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
272 DV100_MAKE_QLEVEL( 1,0), // 1*1= 1
273 DV100_MAKE_QLEVEL( 2,0), // 2*1= 2
274 DV100_MAKE_QLEVEL( 3,0), // 3*1= 3
275 DV100_MAKE_QLEVEL( 4,0), // 4*1= 4
276 DV100_MAKE_QLEVEL( 5,0), // 5*1= 5
277 DV100_MAKE_QLEVEL( 6,0), // 6*1= 6
278 DV100_MAKE_QLEVEL( 7,0), // 7*1= 7
279 DV100_MAKE_QLEVEL( 8,0), // 8*1= 8
280 DV100_MAKE_QLEVEL( 5,1), // 5*2=10
281 DV100_MAKE_QLEVEL( 6,1), // 6*2=12
282 DV100_MAKE_QLEVEL( 7,1), // 7*2=14
283 DV100_MAKE_QLEVEL( 9,0), // 16*1=16
284 DV100_MAKE_QLEVEL(10,0), // 18*1=18
285 DV100_MAKE_QLEVEL(11,0), // 20*1=20
286 DV100_MAKE_QLEVEL(12,0), // 22*1=22
287 DV100_MAKE_QLEVEL(13,0), // 24*1=24
288 DV100_MAKE_QLEVEL(14,0), // 28*1=28
289 DV100_MAKE_QLEVEL( 9,1), // 16*2=32
290 DV100_MAKE_QLEVEL(10,1), // 18*2=36
291 DV100_MAKE_QLEVEL(11,1), // 20*2=40
292 DV100_MAKE_QLEVEL(12,1), // 22*2=44
293 DV100_MAKE_QLEVEL(13,1), // 24*2=48
294 DV100_MAKE_QLEVEL(15,0), // 52*1=52
295 DV100_MAKE_QLEVEL(14,1), // 28*2=56
296 DV100_MAKE_QLEVEL( 9,2), // 16*4=64
297 DV100_MAKE_QLEVEL(10,2), // 18*4=72
298 DV100_MAKE_QLEVEL(11,2), // 20*4=80
299 DV100_MAKE_QLEVEL(12,2), // 22*4=88
300 DV100_MAKE_QLEVEL(13,2), // 24*4=96
302 DV100_MAKE_QLEVEL(15,3), // 52*8=416
305 static const int dv100_min_bias = 0;
306 static const int dv100_chroma_bias = 0;
307 static const int dv100_starting_qno = 1;
309 #if DV100_SACRIFICE_QUALITY_FOR_SPEED
310 static const int dv100_qlevel_inc = 4;
312 static const int dv100_qlevel_inc = 1;
315 // 1/qstep, shifted up by 16 bits
316 static const int dv100_qstep_bits = 16;
317 static const int dv100_qstep_inv[16] = {
318 65536, 65536, 32768, 21845, 16384, 13107, 10923, 9362, 8192, 4096, 3641, 3277, 2979, 2731, 2341, 1260,
321 /* DV100 weights are pre-zigzagged, inverted and multiplied by 2^(dv100_weight_shift)
322 (in DV100 the AC components are divided by the spec weights) */
323 static const int dv100_weight_shift = 16;
324 static const int dv_weight_1080[2][64] = {
325 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
326 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
327 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
328 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
329 25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
330 24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
331 21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
332 10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
333 { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
334 41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
335 40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
336 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
337 25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
338 12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
339 10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
340 5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
343 static const int dv_weight_720[2][64] = {
344 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
345 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
346 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
347 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
348 25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
349 16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
350 10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
351 5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
352 { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
353 29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
354 27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
355 13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
356 12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
357 6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
358 5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
359 2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
362 static av_always_inline int dv_set_class_number_sd(DVVideoContext *s,
363 int16_t *blk, EncBlockInfo *bi,
364 const uint8_t *zigzag_scan,
365 const int *weight, int bias)
368 /* We offer two different methods for class number assignment: the
369 * method suggested in SMPTE 314M Table 22, and an improved
370 * method. The SMPTE method is very conservative; it assigns class
371 * 3 (i.e. severe quantization) to any block where the largest AC
372 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
373 * consumption precisely, so there is no need to bias most blocks
374 * towards strongly lossy compression. Instead, we assign class 2
375 * to most blocks, and use class 3 only when strictly necessary
376 * (for blocks whose largest AC component exceeds 255). */
378 #if 0 /* SMPTE spec method */
379 static const int classes[] = { 12, 24, 36, 0xffff };
380 #else /* improved FFmpeg method */
381 static const int classes[] = { -1, -1, 255, 0xffff };
383 int max = classes[0];
385 const unsigned deadzone = s->quant_deadzone;
386 const unsigned threshold = 2 * deadzone;
390 for (area = 0; area < 4; area++) {
391 bi->prev[area] = prev;
392 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
393 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
394 int level = blk[zigzag_scan[i]];
396 if (level + deadzone > threshold) {
397 bi->sign[i] = (level >> 31) & 1;
398 /* Weight it and shift down into range, adding for rounding.
399 * The extra division by a factor of 2^4 reverses the 8x
400 * expansion of the DCT AND the 2x doubling of the weights. */
401 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
402 (dv_weight_bits + 4);
408 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
415 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
424 for (area = 0; area < 4; area++) {
425 bi->prev[area] = prev;
426 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
427 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
431 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
440 return bi->bit_size[0] + bi->bit_size[1] +
441 bi->bit_size[2] + bi->bit_size[3];
444 /* this function just copies the DCT coefficients and performs
445 the initial (non-)quantization. */
446 static inline void dv_set_class_number_hd(DVVideoContext *s,
447 int16_t *blk, EncBlockInfo *bi,
448 const uint8_t *zigzag_scan,
449 const int *weight, int bias)
453 /* the first quantization (none at all) */
456 /* weigh AC components and store to save[] */
457 /* (i=0 is the DC component; we only include it to make the
458 number of loop iterations even, for future possible SIMD optimization) */
459 for (i = 0; i < 64; i += 2) {
462 /* get the AC component (in zig-zag order) */
463 level0 = blk[zigzag_scan[i+0]];
464 level1 = blk[zigzag_scan[i+1]];
466 /* extract sign and make it the lowest bit */
467 bi->sign[i+0] = (level0>>31)&1;
468 bi->sign[i+1] = (level1>>31)&1;
470 /* take absolute value of the level */
471 level0 = FFABS(level0);
472 level1 = FFABS(level1);
475 level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
476 level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
478 /* save unquantized value */
479 bi->save[i+0] = level0;
480 bi->save[i+1] = level1;
482 /* find max component */
483 if (bi->save[i+0] > max)
485 if (bi->save[i+1] > max)
489 /* copy DC component */
492 /* the EOB code is 4 bits */
494 bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
496 /* ensure that no AC coefficients are cut off */
497 bi->min_qlevel = ((max+256) >> 8);
499 bi->area_q[0] = 25; /* set to an "impossible" value */
503 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
504 DVVideoContext *s, int chroma)
506 LOCAL_ALIGNED_16(int16_t, blk, [64]);
508 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
509 bi->partial_bit_count = 0;
510 bi->partial_bit_buffer = 0;
514 if (DV_PROFILE_IS_HD(s->sys)) {
515 s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
518 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
519 s->get_pixels(blk, data, linesize);
520 s->fdct[bi->dct_mode](blk);
523 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
524 which is precisely what the spec calls for in the "dummy" blocks. */
525 memset(blk, 0, 64*sizeof(*blk));
529 if (DV_PROFILE_IS_HD(s->sys)) {
531 if (s->sys->height == 1080) {
532 weights = dv_weight_1080[chroma];
534 weights = dv_weight_720[chroma];
536 dv_set_class_number_hd(s, blk, bi,
539 dv100_min_bias+chroma*dv100_chroma_bias);
541 dv_set_class_number_sd(s, blk, bi,
542 bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct,
543 bi->dct_mode ? dv_weight_248 : dv_weight_88,
547 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
551 Perform quantization by divinding the AC component by the qstep.
552 As an optimization we use a fixed-point integer multiply instead
554 static av_always_inline int dv100_quantize(int level, int qsinv)
556 /* this code is equivalent to */
557 /* return (level + qs/2) / qs; */
559 return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
561 /* the extra +1024 is needed to make the rounding come out right. */
563 /* I (DJM) have verified that the results are exactly the same as
564 division for level 0-2048 at all QNOs. */
567 static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
571 int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
572 int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
574 if (b->area_q[0] == qno && b->cno == cno)
575 return b->bit_size[0];
577 qsinv = dv100_qstep_inv[qno];
579 /* record the new qstep */
583 /* reset encoded size (EOB = 4 bits) */
586 /* visit nonzero components and quantize */
588 for (k = 1; k < 64; k++) {
590 int ac = dv100_quantize(b->save[k], qsinv) >> cno;
595 b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
602 return b->bit_size[0];
605 static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
612 /* cache block sizes at hypothetical qlevels */
613 uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
615 /* get minimum qlevels */
616 for (i = 0; i < 5; i++) {
618 for (j = 0; j < 8; j++) {
619 if (blks[8*i+j].min_qlevel > min_qlevel[i])
620 min_qlevel[i] = blks[8*i+j].min_qlevel;
624 /* initialize sizes */
625 for (i = 0; i < 5; i++) {
626 qlevels[i] = dv100_starting_qno;
627 if (qlevels[i] < min_qlevel[i])
628 qlevels[i] = min_qlevel[i];
630 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
632 for (j = 0; j < 8; j++) {
633 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
634 size[i] += size_cache[8*i+j][qlevels[i]];
638 /* must we go coarser? */
639 if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
640 int largest = size[0] % 5; /* 'random' number */
641 int qlevels_done = 0;
644 /* find the macroblock with the lowest qlevel */
645 for (i = 0; i < 5; i++) {
646 if (qlevels[i] < qlevels[largest])
651 /* ensure that we don't enter infinite loop */
652 largest = (largest+1) % 5;
654 /* quantize a little bit more */
655 qlevels[i] += dv100_qlevel_inc;
656 if (qlevels[i] > DV100_NUM_QLEVELS-1) {
657 qlevels[i] = DV100_NUM_QLEVELS-1;
661 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
666 for (j = 0; j < 8; j++, b++) {
667 /* accumulate block size into macroblock */
668 if(size_cache[8*i+j][qlevels[i]] == 0) {
669 /* it is safe to use actual_quantize() here because we only go from finer to coarser,
670 and it saves the final actual_quantize() down below */
671 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
673 size[i] += size_cache[8*i+j][qlevels[i]];
674 } /* for each block */
676 } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
679 } else if (DV100_ENABLE_FINER &&
680 size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
682 int largest = size[0] % 5; /* 'random' number */
684 while (qlevels[0] > min_qlevel[0] ||
685 qlevels[1] > min_qlevel[1] ||
686 qlevels[2] > min_qlevel[2] ||
687 qlevels[3] > min_qlevel[3] ||
688 qlevels[4] > min_qlevel[4]) {
690 /* find the macroblock with the highest qlevel */
691 for (i = 0; i < 5; i++) {
692 if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
698 /* ensure that we don't enter infinite loop */
699 largest = (largest+1) % 5;
701 if (qlevels[i] <= min_qlevel[i]) {
702 /* can't unquantize any more */
705 /* quantize a little bit less */
706 save_qlevel = qlevels[i];
707 qlevels[i] -= dv100_qlevel_inc;
708 if (qlevels[i] < min_qlevel[i])
709 qlevels[i] = min_qlevel[i];
711 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
717 for (j = 0; j < 8; j++, b++) {
718 /* accumulate block size into macroblock */
719 if(size_cache[8*i+j][qlevels[i]] == 0) {
720 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
722 size[i] += size_cache[8*i+j][qlevels[i]];
723 } /* for each block */
725 /* did we bust the limit? */
726 if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
727 /* go back down and exit */
728 qlevels[i] = save_qlevel;
729 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
735 /* now do the actual quantization */
736 for (i = 0; i < 5; i++) {
740 for (j = 0; j < 8; j++, b++) {
741 /* accumulate block size into macroblock */
742 size[i] += dv100_actual_quantize(b, qlevels[i]);
743 } /* for each block */
747 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
750 int i, j, k, a, prev, a2;
760 for (i = 0; i < 5; i++) {
766 for (j = 0; j < 6; j++, b++) {
767 for (a = 0; a < 4; a++) {
768 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
769 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
772 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
773 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
776 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
779 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
780 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
783 av_assert2(b->mb[b->next[k]]);
784 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
785 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
786 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
789 b->next[prev] = b->next[k];
792 b->prev[a + 1] = prev;
794 size[i] += b->bit_size[a];
797 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
800 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
802 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
804 size[0] = 5 * 6 * 4; // EOB
805 for (j = 0; j < 6 * 5; j++, b++) {
807 for (k = b->next[prev]; k < 64; k = b->next[k]) {
808 if (b->mb[k] < a && b->mb[k] > -a) {
809 b->next[prev] = b->next[k];
811 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
819 /* update all cno values into the blocks, over-writing the old values without
820 touching anything else. (only used for DV100) */
821 static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
826 for (mb_index = 0; mb_index < 5; mb_index++) {
827 data = dif + mb_index*80 + 4;
828 for (i = 0; i < profile->bpm; i++) {
829 /* zero out the class number */
831 /* add the new one */
832 data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
834 data += profile->block_sizes[i] >> 3;
839 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
841 DVVideoContext *s = avctx->priv_data;
842 DVwork_chunk *work_chunk = arg;
844 int mb_x, mb_y, c_offset;
845 ptrdiff_t linesize, y_stride;
848 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
849 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
850 PutBitContext pbs[5 * DV_MAX_BPM];
852 EncBlockInfo *enc_blk;
855 int *qnosp = &qnos[0];
857 p = dif = &s->buf[work_chunk->buf_offset * 80];
858 enc_blk = &enc_blks[0];
859 for (mb_index = 0; mb_index < 5; mb_index++) {
860 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
862 qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
864 y_ptr = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
865 linesize = s->frame->linesize[0];
867 if (s->sys->height == 1080 && mb_y < 134)
868 enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
870 enc_blk->dct_mode = 0;
871 for (i = 1; i < 8; i++)
872 enc_blk[i].dct_mode = enc_blk->dct_mode;
874 /* initializing luminance blocks */
875 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
876 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
877 (s->sys->height >= 720 && mb_y != 134)) {
878 y_stride = s->frame->linesize[0] * (1 << (3*!enc_blk->dct_mode));
882 y_ptr = s->frame->data[0] +
883 (mb_y * s->frame->linesize[0] + mb_x) * 8;
884 linesize = s->frame->linesize[0];
886 if (s->sys->video_stype == 4) { /* SD 422 */
888 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
889 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
890 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
891 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
894 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
895 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
896 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
897 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
901 /* initializing chrominance blocks */
902 c_offset = ((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
903 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) * 8;
904 for (j = 2; j; j--) {
905 uint8_t *c_ptr = s->frame->data[j] + c_offset;
906 linesize = s->frame->linesize[j];
907 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] * (1 << (3*!enc_blk->dct_mode)));
908 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
910 uint8_t *b = scratch;
911 for (i = 0; i < 8; i++) {
912 d = c_ptr + linesize * 8;
928 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
929 if (s->sys->bpm == 8)
930 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
935 if (DV_PROFILE_IS_HD(s->sys)) {
937 dv_guess_qnos_hd(&enc_blks[0], qnosp);
938 } else if (vs_total_ac_bits < vs_bit_size) {
939 dv_guess_qnos(&enc_blks[0], qnosp);
942 /* DIF encoding process */
943 for (j = 0; j < 5 * s->sys->bpm;) {
949 /* First pass over individual cells only */
950 for (i = 0; i < s->sys->bpm; i++, j++) {
951 int sz = s->sys->block_sizes[i] >> 3;
953 init_put_bits(&pbs[j], p, sz);
954 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
955 put_bits(&pbs[j], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
956 put_bits(&pbs[j], 2, enc_blks[j].cno);
958 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
962 /* Second pass over each MB space */
964 for (i = 0; i < s->sys->bpm; i++)
965 if (enc_blks[start_mb + i].partial_bit_count)
966 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
967 &pbs[start_mb + s->sys->bpm]);
970 /* Third and final pass over the whole video segment space */
972 for (j = 0; j < 5 * s->sys->bpm; j++) {
973 if (enc_blks[j].partial_bit_count)
974 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
975 if (enc_blks[j].partial_bit_count)
976 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
979 for (j = 0; j < 5 * s->sys->bpm; j++) {
981 int size = pbs[j].size_in_bits >> 3;
982 flush_put_bits(&pbs[j]);
983 pos = put_bits_count(&pbs[j]) >> 3;
985 av_log(avctx, AV_LOG_ERROR,
986 "bitstream written beyond buffer size\n");
989 memset(pbs[j].buf + pos, 0xff, size - pos);
992 if (DV_PROFILE_IS_HD(s->sys))
993 dv_revise_cnos(dif, enc_blks, s->sys);
998 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
1002 * Here's what SMPTE314M says about these two:
1003 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1004 * as track application IDs (APTn = 001, AP1n =
1005 * 001, AP2n = 001, AP3n = 001), if the source signal
1006 * comes from a digital VCR. If the signal source is
1007 * unknown, all bits for these data shall be set to 1.
1008 * (page 12) STYPE: STYPE defines a signal type of video signal
1009 * 00000b = 4:1:1 compression
1010 * 00100b = 4:2:2 compression
1012 * Now, I've got two problems with these statements:
1013 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1014 * It seems that for PAL as defined in IEC 61834 we have to set
1015 * APT to 000 and for SMPTE314M to 001.
1016 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1017 * compression scheme (if any).
1020 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1023 if (c->avctx->height >= 720)
1024 fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1026 fs = c->frame->top_field_first ? 0x00 : 0x40;
1028 if (DV_PROFILE_IS_HD(c->sys) ||
1029 (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1030 c->avctx->width / c->avctx->height * 10) >= 17)
1031 /* HD formats are always 16:9 */
1034 buf[0] = (uint8_t) pack_id;
1036 case dv_header525: /* I can't imagine why these two weren't defined as real */
1037 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1038 buf[1] = 0xf8 | /* reserved -- always 1 */
1039 (apt & 0x07); /* APT: Track application ID */
1040 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1041 (0x0f << 3) | /* reserved -- always 1 */
1042 (apt & 0x07); /* AP1: Audio application ID */
1043 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1044 (0x0f << 3) | /* reserved -- always 1 */
1045 (apt & 0x07); /* AP2: Video application ID */
1046 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1047 (0x0f << 3) | /* reserved -- always 1 */
1048 (apt & 0x07); /* AP3: Subcode application ID */
1050 case dv_video_source:
1051 buf[1] = 0xff; /* reserved -- always 1 */
1052 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1053 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1054 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1055 0xf; /* reserved -- always 1 */
1056 buf[3] = (3 << 6) | /* reserved -- always 1 */
1057 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1058 c->sys->video_stype; /* signal type video compression */
1059 buf[4] = 0xff; /* VISC: 0xff -- no information */
1061 case dv_video_control:
1062 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1063 0x3f; /* reserved -- always 1 */
1064 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1066 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1067 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1068 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1069 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1070 0xc; /* reserved -- always b1100 */
1071 buf[4] = 0xff; /* reserved -- always 1 */
1082 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1083 uint8_t seq_num, uint8_t dif_num,
1086 int fsc = chan_num & 1;
1087 int fsp = 1 - (chan_num >> 1);
1089 buf[0] = (uint8_t) t; /* Section type */
1090 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1091 (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1092 (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1093 3; /* reserved -- always 1 */
1094 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1098 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1100 if (syb_num == 0 || syb_num == 6) {
1101 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1102 (0 << 4) | /* AP3 (Subcode application ID) */
1103 0x0f; /* reserved -- always 1 */
1104 } else if (syb_num == 11) {
1105 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1106 0x7f; /* reserved -- always 1 */
1108 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1109 (0 << 4) | /* APT (Track application ID) */
1110 0x0f; /* reserved -- always 1 */
1112 buf[1] = 0xf0 | /* reserved -- always 1 */
1113 (syb_num & 0x0f); /* SSYB number 0 - 11 */
1114 buf[2] = 0xff; /* reserved -- always 1 */
1118 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
1121 /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1122 int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
1124 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1125 for (i = 0; i < c->sys->difseg_size; i++) {
1126 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1128 /* DV header: 1DIF */
1129 buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
1130 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
1132 buf += 72; /* unused bytes */
1134 /* DV subcode: 2DIFs */
1135 for (j = 0; j < 2; j++) {
1136 buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
1137 for (k = 0; k < 6; k++)
1138 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1139 buf += 29; /* unused bytes */
1142 /* DV VAUX: 3DIFS */
1143 for (j = 0; j < 3; j++) {
1144 buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
1145 buf += dv_write_pack(dv_video_source, c, buf);
1146 buf += dv_write_pack(dv_video_control, c, buf);
1148 buf += dv_write_pack(dv_video_source, c, buf);
1149 buf += dv_write_pack(dv_video_control, c, buf);
1150 buf += 4 * 5 + 2; /* unused bytes */
1153 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1154 for (j = 0; j < 135; j++) {
1156 memset(buf, 0xff, 80);
1157 buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
1158 buf += 77; /* audio control & shuffled PCM audio */
1160 buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
1161 buf += 77; /* 1 video macroblock: 1 bytes control
1162 * 4 * 14 bytes Y 8x8 data
1163 * 10 bytes Cr 8x8 data
1164 * 10 bytes Cb 8x8 data */
1170 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1171 const AVFrame *frame, int *got_packet)
1173 DVVideoContext *s = c->priv_data;
1176 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
1179 c->pix_fmt = s->sys->pix_fmt;
1181 #if FF_API_CODED_FRAME
1182 FF_DISABLE_DEPRECATION_WARNINGS
1183 c->coded_frame->key_frame = 1;
1184 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1185 FF_ENABLE_DEPRECATION_WARNINGS
1189 dv_format_frame(s, pkt->data);
1191 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1192 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1196 pkt->flags |= AV_PKT_FLAG_KEY;
1202 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1203 #define OFFSET(x) offsetof(DVVideoContext, x)
1204 static const AVOption dv_options[] = {
1205 { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1209 static const AVClass dvvideo_encode_class = {
1210 .class_name = "dvvideo encoder",
1211 .item_name = av_default_item_name,
1212 .option = dv_options,
1213 .version = LIBAVUTIL_VERSION_INT,
1216 AVCodec ff_dvvideo_encoder = {
1218 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1219 .type = AVMEDIA_TYPE_VIDEO,
1220 .id = AV_CODEC_ID_DVVIDEO,
1221 .priv_data_size = sizeof(DVVideoContext),
1222 .init = dvvideo_encode_init,
1223 .encode2 = dvvideo_encode_frame,
1224 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
1225 .pix_fmts = (const enum AVPixelFormat[]) {
1226 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
1227 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1229 .priv_class = &dvvideo_encode_class,