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^16
322 (in DV100 the AC components are divided by the spec weights) */
323 static const int dv_weight_1080[2][64] = {
324 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
325 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
326 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
327 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
328 25575, 25575, 24385, 23831, 23302, 23302, 24966, 24966,
329 24966, 23302, 23302, 21845, 22795, 24385, 24385, 22795,
330 21845, 21400, 21845, 23831, 21845, 21400, 10382, 10700,
331 10700, 10382, 10082, 9620, 10082, 9039, 9039, 8525, },
332 { 8192, 65536, 65536, 61681, 61681, 61681, 41943, 41943,
333 41943, 41943, 40330, 41943, 40330, 41943, 40330, 40330,
334 40330, 38836, 38836, 40330, 40330, 24966, 27594, 26214,
335 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
336 25575, 25575, 24385, 23831, 11523, 11523, 12483, 12483,
337 12483, 11523, 11523, 10923, 11275, 12193, 12193, 11275,
338 10923, 5323, 5490, 5924, 5490, 5323, 5165, 5323,
339 5323, 5165, 5017, 4788, 5017, 4520, 4520, 4263, }
342 static const int dv_weight_720[2][64] = {
343 { 8192, 65536, 65536, 61681, 61681, 61681, 58254, 58254,
344 58254, 58254, 58254, 58254, 55188, 58254, 58254, 55188,
345 55188, 55188, 55188, 55188, 55188, 24966, 27594, 26214,
346 26214, 26214, 27594, 24966, 23831, 24385, 25575, 25575,
347 25575, 25575, 24385, 23831, 15420, 15420, 16644, 16644,
348 16644, 15420, 15420, 10923, 11398, 12193, 12193, 11398,
349 10923, 10700, 10923, 11916, 10923, 10700, 5191, 5350,
350 5350, 5191, 5041, 4810, 5041, 4520, 4520, 4263, },
351 { 8192, 43691, 43691, 40330, 40330, 40330, 29127, 29127,
352 29127, 29127, 29127, 29127, 27594, 29127, 29127, 27594,
353 27594, 27594, 27594, 27594, 27594, 12483, 13797, 13107,
354 13107, 13107, 13797, 12483, 11916, 12193, 12788, 12788,
355 12788, 12788, 12193, 11916, 5761, 5761, 6242, 6242,
356 6242, 5761, 5761, 5461, 5638, 5461, 6096, 5638,
357 5461, 2661, 2745, 2962, 2745, 2661, 2583, 2661,
358 2661, 2583, 2509, 2394, 2509, 2260, 2260, 2131, }
361 static av_always_inline int dv_set_class_number_sd(DVVideoContext *s,
362 int16_t *blk, EncBlockInfo *bi,
363 const uint8_t *zigzag_scan,
364 const int *weight, int bias)
367 /* We offer two different methods for class number assignment: the
368 * method suggested in SMPTE 314M Table 22, and an improved
369 * method. The SMPTE method is very conservative; it assigns class
370 * 3 (i.e. severe quantization) to any block where the largest AC
371 * component is greater than 36. FFmpeg's DV encoder tracks AC bit
372 * consumption precisely, so there is no need to bias most blocks
373 * towards strongly lossy compression. Instead, we assign class 2
374 * to most blocks, and use class 3 only when strictly necessary
375 * (for blocks whose largest AC component exceeds 255). */
377 #if 0 /* SMPTE spec method */
378 static const int classes[] = { 12, 24, 36, 0xffff };
379 #else /* improved FFmpeg method */
380 static const int classes[] = { -1, -1, 255, 0xffff };
382 int max = classes[0];
384 const unsigned deadzone = s->quant_deadzone;
385 const unsigned threshold = 2 * deadzone;
389 for (area = 0; area < 4; area++) {
390 bi->prev[area] = prev;
391 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
392 for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
393 int level = blk[zigzag_scan[i]];
395 if (level + deadzone > threshold) {
396 bi->sign[i] = (level >> 31) & 1;
397 /* Weight it and shift down into range, adding for rounding.
398 * The extra division by a factor of 2^4 reverses the 8x
399 * expansion of the DCT AND the 2x doubling of the weights. */
400 level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
401 (dv_weight_bits + 4);
407 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
414 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
423 for (area = 0; area < 4; area++) {
424 bi->prev[area] = prev;
425 bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
426 for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
430 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
439 return bi->bit_size[0] + bi->bit_size[1] +
440 bi->bit_size[2] + bi->bit_size[3];
443 /* this function just copies the DCT coefficients and performs
444 the initial (non-)quantization. */
445 static inline void dv_set_class_number_hd(DVVideoContext *s,
446 int16_t *blk, EncBlockInfo *bi,
447 const uint8_t *zigzag_scan,
448 const int *weight, int bias)
452 /* the first quantization (none at all) */
455 /* weigh AC components and store to save[] */
456 /* (i=0 is the DC component; we only include it to make the
457 number of loop iterations even, for future possible SIMD optimization) */
458 for (i = 0; i < 64; i += 2) {
461 /* get the AC component (in zig-zag order) */
462 level0 = blk[zigzag_scan[i+0]];
463 level1 = blk[zigzag_scan[i+1]];
465 /* extract sign and make it the lowest bit */
466 bi->sign[i+0] = (level0>>31)&1;
467 bi->sign[i+1] = (level1>>31)&1;
469 /* take absolute value of the level */
470 level0 = FFABS(level0);
471 level1 = FFABS(level1);
474 level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
475 level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
477 /* save unquantized value */
478 bi->save[i+0] = level0;
479 bi->save[i+1] = level1;
481 /* find max component */
482 if (bi->save[i+0] > max)
484 if (bi->save[i+1] > max)
488 /* copy DC component */
491 /* the EOB code is 4 bits */
493 bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
495 /* ensure that no AC coefficients are cut off */
496 bi->min_qlevel = ((max+256) >> 8);
498 bi->area_q[0] = 25; /* set to an "impossible" value */
502 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
503 DVVideoContext *s, int chroma)
505 LOCAL_ALIGNED_16(int16_t, blk, [64]);
507 bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
508 bi->partial_bit_count = 0;
509 bi->partial_bit_buffer = 0;
513 if (DV_PROFILE_IS_HD(s->sys)) {
514 s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
517 bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
518 s->get_pixels(blk, data, linesize);
519 s->fdct[bi->dct_mode](blk);
522 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
523 which is precisely what the spec calls for in the "dummy" blocks. */
524 memset(blk, 0, 64*sizeof(*blk));
528 if (DV_PROFILE_IS_HD(s->sys)) {
530 if (s->sys->height == 1080) {
531 weights = dv_weight_1080[chroma];
533 weights = dv_weight_720[chroma];
535 dv_set_class_number_hd(s, blk, bi,
538 dv100_min_bias+chroma*dv100_chroma_bias);
540 dv_set_class_number_sd(s, blk, bi,
541 bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct,
542 bi->dct_mode ? dv_weight_248 : dv_weight_88,
546 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
550 Perform quantization by divinding the AC component by the qstep.
551 As an optimization we use a fixed-point integer multiply instead
553 static av_always_inline int dv100_quantize(int level, int qsinv)
555 /* this code is equivalent to */
556 /* return (level + qs/2) / qs; */
558 return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
560 /* the extra +1024 is needed to make the rounding come out right. */
562 /* I (DJM) have verified that the results are exactly the same as
563 division for level 0-2048 at all QNOs. */
566 static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
570 int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
571 int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
573 if (b->area_q[0] == qno && b->cno == cno)
574 return b->bit_size[0];
576 qsinv = dv100_qstep_inv[qno];
578 /* record the new qstep */
582 /* reset encoded size (EOB = 4 bits) */
585 /* visit nonzero components and quantize */
587 for (k = 1; k < 64; k++) {
589 int ac = dv100_quantize(b->save[k], qsinv) >> cno;
594 b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
601 return b->bit_size[0];
604 static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
611 /* cache block sizes at hypothetical qlevels */
612 uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
614 /* get minimum qlevels */
615 for (i = 0; i < 5; i++) {
617 for (j = 0; j < 8; j++) {
618 if (blks[8*i+j].min_qlevel > min_qlevel[i])
619 min_qlevel[i] = blks[8*i+j].min_qlevel;
623 /* initialize sizes */
624 for (i = 0; i < 5; i++) {
625 qlevels[i] = dv100_starting_qno;
626 if (qlevels[i] < min_qlevel[i])
627 qlevels[i] = min_qlevel[i];
629 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
631 for (j = 0; j < 8; j++) {
632 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(&blks[8*i+j], qlevels[i]);
633 size[i] += size_cache[8*i+j][qlevels[i]];
637 /* must we go coarser? */
638 if (size[0]+size[1]+size[2]+size[3]+size[4] > vs_total_ac_bits_hd) {
639 int largest = size[0] % 5; /* 'random' number */
640 int qlevels_done = 0;
643 /* find the macroblock with the lowest qlevel */
644 for (i = 0; i < 5; i++) {
645 if (qlevels[i] < qlevels[largest])
650 /* ensure that we don't enter infinite loop */
651 largest = (largest+1) % 5;
653 /* quantize a little bit more */
654 qlevels[i] += dv100_qlevel_inc;
655 if (qlevels[i] > DV100_NUM_QLEVELS-1) {
656 qlevels[i] = DV100_NUM_QLEVELS-1;
660 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
665 for (j = 0; j < 8; j++, b++) {
666 /* accumulate block size into macroblock */
667 if(size_cache[8*i+j][qlevels[i]] == 0) {
668 /* it is safe to use actual_quantize() here because we only go from finer to coarser,
669 and it saves the final actual_quantize() down below */
670 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
672 size[i] += size_cache[8*i+j][qlevels[i]];
673 } /* for each block */
675 } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
678 } else if (DV100_ENABLE_FINER &&
679 size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
681 int largest = size[0] % 5; /* 'random' number */
683 while (qlevels[0] > min_qlevel[0] ||
684 qlevels[1] > min_qlevel[1] ||
685 qlevels[2] > min_qlevel[2] ||
686 qlevels[3] > min_qlevel[3] ||
687 qlevels[4] > min_qlevel[4]) {
689 /* find the macroblock with the highest qlevel */
690 for (i = 0; i < 5; i++) {
691 if (qlevels[i] > min_qlevel[i] && qlevels[i] > qlevels[largest])
697 /* ensure that we don't enter infinite loop */
698 largest = (largest+1) % 5;
700 if (qlevels[i] <= min_qlevel[i]) {
701 /* can't unquantize any more */
704 /* quantize a little bit less */
705 save_qlevel = qlevels[i];
706 qlevels[i] -= dv100_qlevel_inc;
707 if (qlevels[i] < min_qlevel[i])
708 qlevels[i] = min_qlevel[i];
710 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
716 for (j = 0; j < 8; j++, b++) {
717 /* accumulate block size into macroblock */
718 if(size_cache[8*i+j][qlevels[i]] == 0) {
719 size_cache[8*i+j][qlevels[i]] = dv100_actual_quantize(b, qlevels[i]);
721 size[i] += size_cache[8*i+j][qlevels[i]];
722 } /* for each block */
724 /* did we bust the limit? */
725 if (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4]) {
726 /* go back down and exit */
727 qlevels[i] = save_qlevel;
728 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
734 /* now do the actual quantization */
735 for (i = 0; i < 5; i++) {
739 for (j = 0; j < 8; j++, b++) {
740 /* accumulate block size into macroblock */
741 size[i] += dv100_actual_quantize(b, qlevels[i]);
742 } /* for each block */
746 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
749 int i, j, k, a, prev, a2;
759 for (i = 0; i < 5; i++) {
765 for (j = 0; j < 6; j++, b++) {
766 for (a = 0; a < 4; a++) {
767 if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
768 b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
771 av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
772 for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
775 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
778 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
779 for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
782 av_assert2(b->mb[b->next[k]]);
783 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
784 dv_rl2vlc_size(b->next[k] - k - 1, b->mb[b->next[k]]);
785 av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
788 b->next[prev] = b->next[k];
791 b->prev[a + 1] = prev;
793 size[i] += b->bit_size[a];
796 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
799 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
801 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
803 size[0] = 5 * 6 * 4; // EOB
804 for (j = 0; j < 6 * 5; j++, b++) {
806 for (k = b->next[prev]; k < 64; k = b->next[k]) {
807 if (b->mb[k] < a && b->mb[k] > -a) {
808 b->next[prev] = b->next[k];
810 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
818 /* update all cno values into the blocks, over-writing the old values without
819 touching anything else. (only used for DV100) */
820 static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
825 for (mb_index = 0; mb_index < 5; mb_index++) {
826 data = dif + mb_index*80 + 4;
827 for (i = 0; i < profile->bpm; i++) {
828 /* zero out the class number */
830 /* add the new one */
831 data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
833 data += profile->block_sizes[i] >> 3;
838 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
840 DVVideoContext *s = avctx->priv_data;
841 DVwork_chunk *work_chunk = arg;
843 int mb_x, mb_y, c_offset;
844 ptrdiff_t linesize, y_stride;
847 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
848 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
849 PutBitContext pbs[5 * DV_MAX_BPM];
851 EncBlockInfo *enc_blk;
854 int *qnosp = &qnos[0];
856 p = dif = &s->buf[work_chunk->buf_offset * 80];
857 enc_blk = &enc_blks[0];
858 for (mb_index = 0; mb_index < 5; mb_index++) {
859 dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
861 qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
863 y_ptr = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
864 linesize = s->frame->linesize[0];
866 if (s->sys->height == 1080 && mb_y < 134)
867 enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
869 enc_blk->dct_mode = 0;
870 for (i = 1; i < 8; i++)
871 enc_blk[i].dct_mode = enc_blk->dct_mode;
873 /* initializing luminance blocks */
874 if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P) ||
875 (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
876 (s->sys->height >= 720 && mb_y != 134)) {
877 y_stride = s->frame->linesize[0] * (1 << (3*!enc_blk->dct_mode));
881 y_ptr = s->frame->data[0] +
882 (mb_y * s->frame->linesize[0] + mb_x) * 8;
883 linesize = s->frame->linesize[0];
885 if (s->sys->video_stype == 4) { /* SD 422 */
887 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
888 dv_init_enc_block(enc_blk + 1, NULL, linesize, s, 0) +
889 dv_init_enc_block(enc_blk + 2, y_ptr + 8, linesize, s, 0) +
890 dv_init_enc_block(enc_blk + 3, NULL, linesize, s, 0);
893 dv_init_enc_block(enc_blk + 0, y_ptr, linesize, s, 0) +
894 dv_init_enc_block(enc_blk + 1, y_ptr + 8, linesize, s, 0) +
895 dv_init_enc_block(enc_blk + 2, y_ptr + y_stride, linesize, s, 0) +
896 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
900 /* initializing chrominance blocks */
901 c_offset = ((mb_y >> (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
902 (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) * 8;
903 for (j = 2; j; j--) {
904 uint8_t *c_ptr = s->frame->data[j] + c_offset;
905 linesize = s->frame->linesize[j];
906 y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] * (1 << (3*!enc_blk->dct_mode)));
907 if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
909 uint8_t *b = scratch;
910 for (i = 0; i < 8; i++) {
911 d = c_ptr + linesize * 8;
927 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
928 if (s->sys->bpm == 8)
929 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
934 if (DV_PROFILE_IS_HD(s->sys)) {
936 dv_guess_qnos_hd(&enc_blks[0], qnosp);
937 } else if (vs_total_ac_bits < vs_bit_size) {
938 dv_guess_qnos(&enc_blks[0], qnosp);
941 /* DIF encoding process */
942 for (j = 0; j < 5 * s->sys->bpm;) {
948 /* First pass over individual cells only */
949 for (i = 0; i < s->sys->bpm; i++, j++) {
950 int sz = s->sys->block_sizes[i] >> 3;
952 init_put_bits(&pbs[j], p, sz);
953 put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
954 put_bits(&pbs[j], 1, DV_PROFILE_IS_HD(s->sys) && i ? 1 : enc_blks[j].dct_mode);
955 put_bits(&pbs[j], 2, enc_blks[j].cno);
957 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
961 /* Second pass over each MB space */
963 for (i = 0; i < s->sys->bpm; i++)
964 if (enc_blks[start_mb + i].partial_bit_count)
965 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
966 &pbs[start_mb + s->sys->bpm]);
969 /* Third and final pass over the whole video segment space */
971 for (j = 0; j < 5 * s->sys->bpm; j++) {
972 if (enc_blks[j].partial_bit_count)
973 pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
974 if (enc_blks[j].partial_bit_count)
975 av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
978 for (j = 0; j < 5 * s->sys->bpm; j++) {
979 flush_put_bits(&pbs[j]);
980 memset(put_bits_ptr(&pbs[j]), 0xff, put_bytes_left(&pbs[j], 0));
983 if (DV_PROFILE_IS_HD(s->sys))
984 dv_revise_cnos(dif, enc_blks, s->sys);
989 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
993 * Here's what SMPTE314M says about these two:
994 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
995 * as track application IDs (APTn = 001, AP1n =
996 * 001, AP2n = 001, AP3n = 001), if the source signal
997 * comes from a digital VCR. If the signal source is
998 * unknown, all bits for these data shall be set to 1.
999 * (page 12) STYPE: STYPE defines a signal type of video signal
1000 * 00000b = 4:1:1 compression
1001 * 00100b = 4:2:2 compression
1003 * Now, I've got two problems with these statements:
1004 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1005 * It seems that for PAL as defined in IEC 61834 we have to set
1006 * APT to 000 and for SMPTE314M to 001.
1007 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1008 * compression scheme (if any).
1011 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1014 if (c->avctx->height >= 720)
1015 fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1017 fs = c->frame->top_field_first ? 0x00 : 0x40;
1019 if (DV_PROFILE_IS_HD(c->sys) ||
1020 (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1021 c->avctx->width / c->avctx->height * 10) >= 17)
1022 /* HD formats are always 16:9 */
1025 buf[0] = (uint8_t) pack_id;
1027 case dv_header525: /* I can't imagine why these two weren't defined as real */
1028 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1029 buf[1] = 0xf8 | /* reserved -- always 1 */
1030 (apt & 0x07); /* APT: Track application ID */
1031 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1032 (0x0f << 3) | /* reserved -- always 1 */
1033 (apt & 0x07); /* AP1: Audio application ID */
1034 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1035 (0x0f << 3) | /* reserved -- always 1 */
1036 (apt & 0x07); /* AP2: Video application ID */
1037 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1038 (0x0f << 3) | /* reserved -- always 1 */
1039 (apt & 0x07); /* AP3: Subcode application ID */
1041 case dv_video_source:
1042 buf[1] = 0xff; /* reserved -- always 1 */
1043 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1044 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1045 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1046 0xf; /* reserved -- always 1 */
1047 buf[3] = (3 << 6) | /* reserved -- always 1 */
1048 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1049 c->sys->video_stype; /* signal type video compression */
1050 buf[4] = 0xff; /* VISC: 0xff -- no information */
1052 case dv_video_control:
1053 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1054 0x3f; /* reserved -- always 1 */
1055 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1057 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1058 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1059 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1060 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1061 0xc; /* reserved -- always b1100 */
1062 buf[4] = 0xff; /* reserved -- always 1 */
1073 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1074 uint8_t seq_num, uint8_t dif_num,
1077 int fsc = chan_num & 1;
1078 int fsp = 1 - (chan_num >> 1);
1080 buf[0] = (uint8_t) t; /* Section type */
1081 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1082 (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1083 (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1084 3; /* reserved -- always 1 */
1085 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1089 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1091 if (syb_num == 0 || syb_num == 6) {
1092 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1093 (0 << 4) | /* AP3 (Subcode application ID) */
1094 0x0f; /* reserved -- always 1 */
1095 } else if (syb_num == 11) {
1096 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1097 0x7f; /* reserved -- always 1 */
1099 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1100 (0 << 4) | /* APT (Track application ID) */
1101 0x0f; /* reserved -- always 1 */
1103 buf[1] = 0xf0 | /* reserved -- always 1 */
1104 (syb_num & 0x0f); /* SSYB number 0 - 11 */
1105 buf[2] = 0xff; /* reserved -- always 1 */
1109 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
1112 /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1113 int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
1115 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1116 for (i = 0; i < c->sys->difseg_size; i++) {
1117 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1119 /* DV header: 1DIF */
1120 buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
1121 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
1123 buf += 72; /* unused bytes */
1125 /* DV subcode: 2DIFs */
1126 for (j = 0; j < 2; j++) {
1127 buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
1128 for (k = 0; k < 6; k++)
1129 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1130 buf += 29; /* unused bytes */
1133 /* DV VAUX: 3DIFS */
1134 for (j = 0; j < 3; j++) {
1135 buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
1136 buf += dv_write_pack(dv_video_source, c, buf);
1137 buf += dv_write_pack(dv_video_control, c, buf);
1139 buf += dv_write_pack(dv_video_source, c, buf);
1140 buf += dv_write_pack(dv_video_control, c, buf);
1141 buf += 4 * 5 + 2; /* unused bytes */
1144 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1145 for (j = 0; j < 135; j++) {
1147 memset(buf, 0xff, 80);
1148 buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
1149 buf += 77; /* audio control & shuffled PCM audio */
1151 buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
1152 buf += 77; /* 1 video macroblock: 1 bytes control
1153 * 4 * 14 bytes Y 8x8 data
1154 * 10 bytes Cr 8x8 data
1155 * 10 bytes Cb 8x8 data */
1161 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1162 const AVFrame *frame, int *got_packet)
1164 DVVideoContext *s = c->priv_data;
1167 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
1170 c->pix_fmt = s->sys->pix_fmt;
1174 dv_format_frame(s, pkt->data);
1176 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1177 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1181 pkt->flags |= AV_PKT_FLAG_KEY;
1187 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1188 #define OFFSET(x) offsetof(DVVideoContext, x)
1189 static const AVOption dv_options[] = {
1190 { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1194 static const AVClass dvvideo_encode_class = {
1195 .class_name = "dvvideo encoder",
1196 .item_name = av_default_item_name,
1197 .option = dv_options,
1198 .version = LIBAVUTIL_VERSION_INT,
1201 AVCodec ff_dvvideo_encoder = {
1203 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1204 .type = AVMEDIA_TYPE_VIDEO,
1205 .id = AV_CODEC_ID_DVVIDEO,
1206 .priv_data_size = sizeof(DVVideoContext),
1207 .init = dvvideo_encode_init,
1208 .encode2 = dvvideo_encode_frame,
1209 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
1210 .pix_fmts = (const enum AVPixelFormat[]) {
1211 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
1212 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1214 .priv_class = &dvvideo_encode_class,