1 /*
2 * DV encoder
3 * Copyright (c) 2003 Roman Shaposhnik
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 *
21 * quant_deadzone code and fixes sponsored by NOA GmbH
22 */
23
24 /**
25 * @file
26 * DV encoder
27 */
28
29 #include "config.h"
30
31 #include "libavutil/attributes.h"
32 #include "libavutil/internal.h"
33 #include "libavutil/mem_internal.h"
34 #include "libavutil/opt.h"
35 #include "libavutil/pixdesc.h"
36
37 #include "avcodec.h"
38 #include "dv.h"
39 #include "dv_profile_internal.h"
40 #include "dv_tablegen.h"
41 #include "fdctdsp.h"
42 #include "internal.h"
43 #include "mathops.h"
44 #include "me_cmp.h"
45 #include "pixblockdsp.h"
46 #include "put_bits.h"
47
dvvideo_encode_init(AVCodecContext * avctx)48 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
49 {
50 DVVideoContext *s = avctx->priv_data;
51 FDCTDSPContext fdsp;
52 MECmpContext mecc;
53 PixblockDSPContext pdsp;
54 int ret;
55
56 s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
57 if (!s->sys) {
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);
63 }
64
65 ret = ff_dv_init_dynamic_tables(s, s->sys);
66 if (ret < 0) {
67 av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
68 return ret;
69 }
70
71 dv_vlc_map_tableinit();
72
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);
80
81 s->get_pixels = pdsp.get_pixels;
82 s->ildct_cmp = mecc.ildct_cmp[5];
83
84 s->fdct[0] = fdsp.fdct;
85 s->fdct[1] = fdsp.fdct248;
86
87 return ff_dvvideo_init(avctx);
88 }
89
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 };
94
95 #if CONFIG_SMALL
96 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
dv_rl2vlc(int run,int level,int sign,uint32_t * vlc)97 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
98 uint32_t *vlc)
99 {
100 int size;
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;
104 } else {
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;
108 } else {
109 *vlc = 0xfe00 | (level << 1) | sign;
110 size = 16;
111 }
112 if (run) {
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;
116 }
117 }
118
119 return size;
120 }
121
dv_rl2vlc_size(int run,int level)122 static av_always_inline int dv_rl2vlc_size(int run, int level)
123 {
124 int size;
125
126 if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
127 size = dv_vlc_map[run][level].size;
128 } else {
129 size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
130 if (run)
131 size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
132 }
133 return size;
134 }
135 #else
dv_rl2vlc(int run,int l,int sign,uint32_t * vlc)136 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
137 {
138 *vlc = dv_vlc_map[run][l].vlc | sign;
139 return dv_vlc_map[run][l].size;
140 }
141
dv_rl2vlc_size(int run,int l)142 static av_always_inline int dv_rl2vlc_size(int run, int l)
143 {
144 return dv_vlc_map[run][l].size;
145 }
146 #endif
147
148 typedef struct EncBlockInfo {
149 int area_q[4];
150 int bit_size[4];
151 int prev[5];
152 int cur_ac;
153 int cno;
154 int dct_mode;
155 int16_t mb[64];
156 uint8_t next[64];
157 uint8_t sign[64];
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. */
163 int16_t save[64];
164 int min_qlevel; /* DV100 only: minimum qlevel (for AC coefficients >255) */
165 } EncBlockInfo;
166
dv_encode_ac(EncBlockInfo * bi,PutBitContext * pb_pool,PutBitContext * pb_end)167 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
168 PutBitContext *pb_pool,
169 PutBitContext *pb_end)
170 {
171 int prev, bits_left;
172 PutBitContext *pb = pb_pool;
173 int size = bi->partial_bit_count;
174 uint32_t vlc = bi->partial_bit_buffer;
175
176 bi->partial_bit_count =
177 bi->partial_bit_buffer = 0;
178 for (;;) {
179 /* Find suitable storage space */
180 for (; size > (bits_left = put_bits_left(pb)); pb++) {
181 if (bits_left) {
182 size -= bits_left;
183 put_bits(pb, bits_left, vlc >> size);
184 vlc = av_mod_uintp2(vlc, size);
185 }
186 if (pb + 1 >= pb_end) {
187 bi->partial_bit_count = size;
188 bi->partial_bit_buffer = vlc;
189 return pb;
190 }
191 }
192
193 /* Store VLC */
194 put_bits(pb, size, vlc);
195
196 if (bi->cur_ac >= 64)
197 break;
198
199 /* Construct the next VLC */
200 prev = bi->cur_ac;
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);
205 } else {
206 size = 4;
207 vlc = 6; /* End Of Block stamp */
208 }
209 }
210 return pb;
211 }
212
dv_guess_dct_mode(DVVideoContext * s,uint8_t * data,ptrdiff_t linesize)213 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
214 ptrdiff_t linesize)
215 {
216 if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
217 int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
218 if (ps > 0) {
219 int is = s->ildct_cmp(NULL, data, NULL, linesize * 2, 4) +
220 s->ildct_cmp(NULL, data + linesize, NULL, linesize * 2, 4);
221 return ps > is;
222 }
223 }
224
225 return 0;
226 }
227
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,
238 };
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,
248 };
249
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
254
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)
259
260 #define DV100_NUM_QLEVELS 31
261
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
301 // ...
302 DV100_MAKE_QLEVEL(15,3), // 52*8=416
303 };
304
305 static const int dv100_min_bias = 0;
306 static const int dv100_chroma_bias = 0;
307 static const int dv100_starting_qno = 1;
308
309 #if DV100_SACRIFICE_QUALITY_FOR_SPEED
310 static const int dv100_qlevel_inc = 4;
311 #else
312 static const int dv100_qlevel_inc = 1;
313 #endif
314
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,
319 };
320
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, }
340 };
341
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, }
359 };
360
dv_set_class_number_sd(DVVideoContext * s,int16_t * blk,EncBlockInfo * bi,const uint8_t * zigzag_scan,const int * weight,int bias)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)
365 {
366 int i, area;
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). */
376
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 };
381 #endif
382 int max = classes[0];
383 int prev = 0;
384 const unsigned deadzone = s->quant_deadzone;
385 const unsigned threshold = 2 * deadzone;
386
387 bi->mb[0] = blk[0];
388
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]];
394
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);
402 if (!level)
403 continue;
404 bi->mb[i] = level;
405 if (level > max)
406 max = level;
407 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
408 bi->next[prev] = i;
409 prev = i;
410 }
411 }
412 }
413 bi->next[prev] = i;
414 for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
415 ;
416
417 bi->cno += bias;
418
419 if (bi->cno >= 3) {
420 bi->cno = 3;
421 prev = 0;
422 i = bi->next[prev];
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]) {
427 bi->mb[i] >>= 1;
428
429 if (bi->mb[i]) {
430 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
431 bi->next[prev] = i;
432 prev = i;
433 }
434 }
435 }
436 bi->next[prev] = i;
437 }
438
439 return bi->bit_size[0] + bi->bit_size[1] +
440 bi->bit_size[2] + bi->bit_size[3];
441 }
442
443 /* this function just copies the DCT coefficients and performs
444 the initial (non-)quantization. */
dv_set_class_number_hd(DVVideoContext * s,int16_t * blk,EncBlockInfo * bi,const uint8_t * zigzag_scan,const int * weight,int bias)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)
449 {
450 int i, max = 0;
451
452 /* the first quantization (none at all) */
453 bi->area_q[0] = 1;
454
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) {
459 int level0, level1;
460
461 /* get the AC component (in zig-zag order) */
462 level0 = blk[zigzag_scan[i+0]];
463 level1 = blk[zigzag_scan[i+1]];
464
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;
468
469 /* take absolute value of the level */
470 level0 = FFABS(level0);
471 level1 = FFABS(level1);
472
473 /* weigh it */
474 level0 = (level0*weight[i+0] + 4096 + (1<<17)) >> 18;
475 level1 = (level1*weight[i+1] + 4096 + (1<<17)) >> 18;
476
477 /* save unquantized value */
478 bi->save[i+0] = level0;
479 bi->save[i+1] = level1;
480
481 /* find max component */
482 if (bi->save[i+0] > max)
483 max = bi->save[i+0];
484 if (bi->save[i+1] > max)
485 max = bi->save[i+1];
486 }
487
488 /* copy DC component */
489 bi->mb[0] = blk[0];
490
491 /* the EOB code is 4 bits */
492 bi->bit_size[0] = 4;
493 bi->bit_size[1] = bi->bit_size[2] = bi->bit_size[3] = 0;
494
495 /* ensure that no AC coefficients are cut off */
496 bi->min_qlevel = ((max+256) >> 8);
497
498 bi->area_q[0] = 25; /* set to an "impossible" value */
499 bi->cno = 0;
500 }
501
dv_init_enc_block(EncBlockInfo * bi,uint8_t * data,int linesize,DVVideoContext * s,int chroma)502 static av_always_inline int dv_init_enc_block(EncBlockInfo* bi, uint8_t *data, int linesize,
503 DVVideoContext *s, int chroma)
504 {
505 LOCAL_ALIGNED_16(int16_t, blk, [64]);
506
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;
510 bi->cur_ac = 0;
511
512 if (data) {
513 if (DV_PROFILE_IS_HD(s->sys)) {
514 s->get_pixels(blk, data, linesize * (1 << bi->dct_mode));
515 s->fdct[0](blk);
516 } else {
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);
520 }
521 } else {
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));
525 bi->dct_mode = 0;
526 }
527
528 if (DV_PROFILE_IS_HD(s->sys)) {
529 const int *weights;
530 if (s->sys->height == 1080) {
531 weights = dv_weight_1080[chroma];
532 } else { /* 720p */
533 weights = dv_weight_720[chroma];
534 }
535 dv_set_class_number_hd(s, blk, bi,
536 ff_zigzag_direct,
537 weights,
538 dv100_min_bias+chroma*dv100_chroma_bias);
539 } else {
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,
543 chroma);
544 }
545
546 return bi->bit_size[0] + bi->bit_size[1] + bi->bit_size[2] + bi->bit_size[3];
547 }
548
549 /* DV100 quantize
550 Perform quantization by divinding the AC component by the qstep.
551 As an optimization we use a fixed-point integer multiply instead
552 of a divide. */
dv100_quantize(int level,int qsinv)553 static av_always_inline int dv100_quantize(int level, int qsinv)
554 {
555 /* this code is equivalent to */
556 /* return (level + qs/2) / qs; */
557
558 return (level * qsinv + 1024 + (1<<(dv100_qstep_bits-1))) >> dv100_qstep_bits;
559
560 /* the extra +1024 is needed to make the rounding come out right. */
561
562 /* I (DJM) have verified that the results are exactly the same as
563 division for level 0-2048 at all QNOs. */
564 }
565
dv100_actual_quantize(EncBlockInfo * b,int qlevel)566 static int dv100_actual_quantize(EncBlockInfo *b, int qlevel)
567 {
568 int prev, k, qsinv;
569
570 int qno = DV100_QLEVEL_QNO(dv100_qlevels[qlevel]);
571 int cno = DV100_QLEVEL_CNO(dv100_qlevels[qlevel]);
572
573 if (b->area_q[0] == qno && b->cno == cno)
574 return b->bit_size[0];
575
576 qsinv = dv100_qstep_inv[qno];
577
578 /* record the new qstep */
579 b->area_q[0] = qno;
580 b->cno = cno;
581
582 /* reset encoded size (EOB = 4 bits) */
583 b->bit_size[0] = 4;
584
585 /* visit nonzero components and quantize */
586 prev = 0;
587 for (k = 1; k < 64; k++) {
588 /* quantize */
589 int ac = dv100_quantize(b->save[k], qsinv) >> cno;
590 if (ac) {
591 if (ac > 255)
592 ac = 255;
593 b->mb[k] = ac;
594 b->bit_size[0] += dv_rl2vlc_size(k - prev - 1, ac);
595 b->next[prev] = k;
596 prev = k;
597 }
598 }
599 b->next[prev] = k;
600
601 return b->bit_size[0];
602 }
603
dv_guess_qnos_hd(EncBlockInfo * blks,int * qnos)604 static inline void dv_guess_qnos_hd(EncBlockInfo *blks, int *qnos)
605 {
606 EncBlockInfo *b;
607 int min_qlevel[5];
608 int qlevels[5];
609 int size[5];
610 int i, j;
611 /* cache block sizes at hypothetical qlevels */
612 uint16_t size_cache[5*8][DV100_NUM_QLEVELS] = {{0}};
613
614 /* get minimum qlevels */
615 for (i = 0; i < 5; i++) {
616 min_qlevel[i] = 1;
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;
620 }
621 }
622
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];
628
629 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
630 size[i] = 0;
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]];
634 }
635 }
636
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;
641
642 do {
643 /* find the macroblock with the lowest qlevel */
644 for (i = 0; i < 5; i++) {
645 if (qlevels[i] < qlevels[largest])
646 largest = i;
647 }
648
649 i = largest;
650 /* ensure that we don't enter infinite loop */
651 largest = (largest+1) % 5;
652
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;
657 qlevels_done++;
658 }
659
660 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
661 size[i] = 0;
662
663 /* for each block */
664 b = &blks[8*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]);
671 }
672 size[i] += size_cache[8*i+j][qlevels[i]];
673 } /* for each block */
674
675 } while (vs_total_ac_bits_hd < size[0] + size[1] + size[2] + size[3] + size[4] && qlevels_done < 5);
676
677 // can we go finer?
678 } else if (DV100_ENABLE_FINER &&
679 size[0]+size[1]+size[2]+size[3]+size[4] < vs_total_ac_bits_hd) {
680 int save_qlevel;
681 int largest = size[0] % 5; /* 'random' number */
682
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]) {
688
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])
692 largest = i;
693 }
694
695 i = largest;
696
697 /* ensure that we don't enter infinite loop */
698 largest = (largest+1) % 5;
699
700 if (qlevels[i] <= min_qlevel[i]) {
701 /* can't unquantize any more */
702 continue;
703 }
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];
709
710 qnos[i] = DV100_QLEVEL_QNO(dv100_qlevels[qlevels[i]]);
711
712 size[i] = 0;
713
714 /* for each block */
715 b = &blks[8*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]);
720 }
721 size[i] += size_cache[8*i+j][qlevels[i]];
722 } /* for each block */
723
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]]);
729 break;
730 }
731 }
732 }
733
734 /* now do the actual quantization */
735 for (i = 0; i < 5; i++) {
736 /* for each block */
737 b = &blks[8*i];
738 size[i] = 0;
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 */
743 }
744 }
745
dv_guess_qnos(EncBlockInfo * blks,int * qnos)746 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
747 {
748 int size[5];
749 int i, j, k, a, prev, a2;
750 EncBlockInfo *b;
751
752 size[0] =
753 size[1] =
754 size[2] =
755 size[3] =
756 size[4] = 1 << 24;
757 do {
758 b = blks;
759 for (i = 0; i < 5; i++) {
760 if (!qnos[i])
761 continue;
762
763 qnos[i]--;
764 size[i] = 0;
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 :)
769 b->area_q[a]++;
770 prev = b->prev[a];
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]) {
773 b->mb[k] >>= 1;
774 if (b->mb[k]) {
775 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
776 prev = k;
777 } else {
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++)
780 b->prev[a2] = prev;
781 av_assert2(a2 < 4);
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));
786 b->prev[a2] = prev;
787 }
788 b->next[prev] = b->next[k];
789 }
790 }
791 b->prev[a + 1] = prev;
792 }
793 size[i] += b->bit_size[a];
794 }
795 }
796 if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
797 return;
798 }
799 } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
800
801 for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
802 b = blks;
803 size[0] = 5 * 6 * 4; // EOB
804 for (j = 0; j < 6 * 5; j++, b++) {
805 prev = b->prev[0];
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];
809 } else {
810 size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
811 prev = k;
812 }
813 }
814 }
815 }
816 }
817
818 /* update all cno values into the blocks, over-writing the old values without
819 touching anything else. (only used for DV100) */
dv_revise_cnos(uint8_t * dif,EncBlockInfo * blk,const AVDVProfile * profile)820 static inline void dv_revise_cnos(uint8_t *dif, EncBlockInfo *blk, const AVDVProfile *profile)
821 {
822 uint8_t *data;
823 int mb_index, i;
824
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 */
829 data[1] &= 0xCF;
830 /* add the new one */
831 data[1] |= blk[profile->bpm*mb_index+i].cno << 4;
832
833 data += profile->block_sizes[i] >> 3;
834 }
835 }
836 }
837
dv_encode_video_segment(AVCodecContext * avctx,void * arg)838 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
839 {
840 DVVideoContext *s = avctx->priv_data;
841 DVwork_chunk *work_chunk = arg;
842 int mb_index, i, j;
843 int mb_x, mb_y, c_offset;
844 ptrdiff_t linesize, y_stride;
845 uint8_t *y_ptr;
846 uint8_t *dif, *p;
847 LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
848 EncBlockInfo enc_blks[5 * DV_MAX_BPM];
849 PutBitContext pbs[5 * DV_MAX_BPM];
850 PutBitContext *pb;
851 EncBlockInfo *enc_blk;
852 int vs_bit_size = 0;
853 int qnos[5];
854 int *qnosp = &qnos[0];
855
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);
860
861 qnos[mb_index] = DV_PROFILE_IS_HD(s->sys) ? 1 : 15;
862
863 y_ptr = s->frame->data[0] + (mb_y * s->frame->linesize[0] + mb_x) * 8;
864 linesize = s->frame->linesize[0];
865
866 if (s->sys->height == 1080 && mb_y < 134)
867 enc_blk->dct_mode = dv_guess_dct_mode(s, y_ptr, linesize);
868 else
869 enc_blk->dct_mode = 0;
870 for (i = 1; i < 8; i++)
871 enc_blk[i].dct_mode = enc_blk->dct_mode;
872
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));
878 } else {
879 y_stride = 16;
880 }
881 y_ptr = s->frame->data[0] +
882 (mb_y * s->frame->linesize[0] + mb_x) * 8;
883 linesize = s->frame->linesize[0];
884
885 if (s->sys->video_stype == 4) { /* SD 422 */
886 vs_bit_size +=
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);
891 } else {
892 vs_bit_size +=
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);
897 }
898 enc_blk += 4;
899
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)) {
908 uint8_t *d;
909 uint8_t *b = scratch;
910 for (i = 0; i < 8; i++) {
911 d = c_ptr + linesize * 8;
912 b[0] = c_ptr[0];
913 b[1] = c_ptr[1];
914 b[2] = c_ptr[2];
915 b[3] = c_ptr[3];
916 b[4] = d[0];
917 b[5] = d[1];
918 b[6] = d[2];
919 b[7] = d[3];
920 c_ptr += linesize;
921 b += 16;
922 }
923 c_ptr = scratch;
924 linesize = 16;
925 }
926
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,
930 linesize, s, 1);
931 }
932 }
933
934 if (DV_PROFILE_IS_HD(s->sys)) {
935 /* unconditional */
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);
939 }
940
941 /* DIF encoding process */
942 for (j = 0; j < 5 * s->sys->bpm;) {
943 int start_mb = j;
944
945 p[3] = *qnosp++;
946 p += 4;
947
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;
951
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);
956
957 dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
958 p += sz;
959 }
960
961 /* Second pass over each MB space */
962 pb = &pbs[start_mb];
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]);
967 }
968
969 /* Third and final pass over the whole video segment space */
970 pb = &pbs[0];
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");
976 }
977
978 for (j = 0; j < 5 * s->sys->bpm; j++) {
979 int pos;
980 int size = pbs[j].size_in_bits >> 3;
981 flush_put_bits(&pbs[j]);
982 pos = put_bits_count(&pbs[j]) >> 3;
983 if (pos > size) {
984 av_log(avctx, AV_LOG_ERROR,
985 "bitstream written beyond buffer size\n");
986 return -1;
987 }
988 memset(pbs[j].buf + pos, 0xff, size - pos);
989 }
990
991 if (DV_PROFILE_IS_HD(s->sys))
992 dv_revise_cnos(dif, enc_blks, s->sys);
993
994 return 0;
995 }
996
dv_write_pack(enum dv_pack_type pack_id,DVVideoContext * c,uint8_t * buf)997 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
998 uint8_t *buf)
999 {
1000 /*
1001 * Here's what SMPTE314M says about these two:
1002 * (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1003 * as track application IDs (APTn = 001, AP1n =
1004 * 001, AP2n = 001, AP3n = 001), if the source signal
1005 * comes from a digital VCR. If the signal source is
1006 * unknown, all bits for these data shall be set to 1.
1007 * (page 12) STYPE: STYPE defines a signal type of video signal
1008 * 00000b = 4:1:1 compression
1009 * 00100b = 4:2:2 compression
1010 * XXXXXX = Reserved
1011 * Now, I've got two problems with these statements:
1012 * 1. it looks like APT == 111b should be a safe bet, but it isn't.
1013 * It seems that for PAL as defined in IEC 61834 we have to set
1014 * APT to 000 and for SMPTE314M to 001.
1015 * 2. It is not at all clear what STYPE is used for 4:2:0 PAL
1016 * compression scheme (if any).
1017 */
1018 uint8_t aspect = 0;
1019 int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
1020 int fs;
1021
1022 if (c->avctx->height >= 720)
1023 fs = c->avctx->height == 720 || c->frame->top_field_first ? 0x40 : 0x00;
1024 else
1025 fs = c->frame->top_field_first ? 0x00 : 0x40;
1026
1027 if (DV_PROFILE_IS_HD(c->sys) ||
1028 (int)(av_q2d(c->avctx->sample_aspect_ratio) *
1029 c->avctx->width / c->avctx->height * 10) >= 17)
1030 /* HD formats are always 16:9 */
1031 aspect = 0x02;
1032
1033 buf[0] = (uint8_t) pack_id;
1034 switch (pack_id) {
1035 case dv_header525: /* I can't imagine why these two weren't defined as real */
1036 case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1037 buf[1] = 0xf8 | /* reserved -- always 1 */
1038 (apt & 0x07); /* APT: Track application ID */
1039 buf[2] = (0 << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
1040 (0x0f << 3) | /* reserved -- always 1 */
1041 (apt & 0x07); /* AP1: Audio application ID */
1042 buf[3] = (0 << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
1043 (0x0f << 3) | /* reserved -- always 1 */
1044 (apt & 0x07); /* AP2: Video application ID */
1045 buf[4] = (0 << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1046 (0x0f << 3) | /* reserved -- always 1 */
1047 (apt & 0x07); /* AP3: Subcode application ID */
1048 break;
1049 case dv_video_source:
1050 buf[1] = 0xff; /* reserved -- always 1 */
1051 buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1052 (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1053 (3 << 4) | /* CLF: color frames ID (see ITU-R BT.470-4) */
1054 0xf; /* reserved -- always 1 */
1055 buf[3] = (3 << 6) | /* reserved -- always 1 */
1056 (c->sys->dsf << 5) | /* system: 60fields/50fields */
1057 c->sys->video_stype; /* signal type video compression */
1058 buf[4] = 0xff; /* VISC: 0xff -- no information */
1059 break;
1060 case dv_video_control:
1061 buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1062 0x3f; /* reserved -- always 1 */
1063 buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1064 aspect;
1065 buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
1066 fs | /* first/second field flag 0 -- field 2, 1 -- field 1 */
1067 (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
1068 (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1069 0xc; /* reserved -- always b1100 */
1070 buf[4] = 0xff; /* reserved -- always 1 */
1071 break;
1072 default:
1073 buf[1] =
1074 buf[2] =
1075 buf[3] =
1076 buf[4] = 0xff;
1077 }
1078 return 5;
1079 }
1080
dv_write_dif_id(enum dv_section_type t,uint8_t chan_num,uint8_t seq_num,uint8_t dif_num,uint8_t * buf)1081 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
1082 uint8_t seq_num, uint8_t dif_num,
1083 uint8_t *buf)
1084 {
1085 int fsc = chan_num & 1;
1086 int fsp = 1 - (chan_num >> 1);
1087
1088 buf[0] = (uint8_t) t; /* Section type */
1089 buf[1] = (seq_num << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
1090 (fsc << 3) | /* FSC: for 50 and 100Mb/s 0 - first channel; 1 - second */
1091 (fsp << 2) | /* FSP: for 100Mb/s 1 - channels 0-1; 0 - channels 2-3 */
1092 3; /* reserved -- always 1 */
1093 buf[2] = dif_num; /* DIF block number Video: 0-134, Audio: 0-8 */
1094 return 3;
1095 }
1096
dv_write_ssyb_id(uint8_t syb_num,uint8_t fr,uint8_t * buf)1097 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
1098 {
1099 if (syb_num == 0 || syb_num == 6) {
1100 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1101 (0 << 4) | /* AP3 (Subcode application ID) */
1102 0x0f; /* reserved -- always 1 */
1103 } else if (syb_num == 11) {
1104 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1105 0x7f; /* reserved -- always 1 */
1106 } else {
1107 buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
1108 (0 << 4) | /* APT (Track application ID) */
1109 0x0f; /* reserved -- always 1 */
1110 }
1111 buf[1] = 0xf0 | /* reserved -- always 1 */
1112 (syb_num & 0x0f); /* SSYB number 0 - 11 */
1113 buf[2] = 0xff; /* reserved -- always 1 */
1114 return 3;
1115 }
1116
dv_format_frame(DVVideoContext * c,uint8_t * buf)1117 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
1118 {
1119 int chan, i, j, k;
1120 /* We work with 720p frames split in half. The odd half-frame is chan 2,3 */
1121 int chan_offset = 2*(c->sys->height == 720 && c->avctx->frame_number & 1);
1122
1123 for (chan = 0; chan < c->sys->n_difchan; chan++) {
1124 for (i = 0; i < c->sys->difseg_size; i++) {
1125 memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
1126
1127 /* DV header: 1DIF */
1128 buf += dv_write_dif_id(dv_sect_header, chan+chan_offset, i, 0, buf);
1129 buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
1130 c, buf);
1131 buf += 72; /* unused bytes */
1132
1133 /* DV subcode: 2DIFs */
1134 for (j = 0; j < 2; j++) {
1135 buf += dv_write_dif_id(dv_sect_subcode, chan+chan_offset, i, j, buf);
1136 for (k = 0; k < 6; k++)
1137 buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
1138 buf += 29; /* unused bytes */
1139 }
1140
1141 /* DV VAUX: 3DIFS */
1142 for (j = 0; j < 3; j++) {
1143 buf += dv_write_dif_id(dv_sect_vaux, chan+chan_offset, i, j, buf);
1144 buf += dv_write_pack(dv_video_source, c, buf);
1145 buf += dv_write_pack(dv_video_control, c, buf);
1146 buf += 7 * 5;
1147 buf += dv_write_pack(dv_video_source, c, buf);
1148 buf += dv_write_pack(dv_video_control, c, buf);
1149 buf += 4 * 5 + 2; /* unused bytes */
1150 }
1151
1152 /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1153 for (j = 0; j < 135; j++) {
1154 if (j % 15 == 0) {
1155 memset(buf, 0xff, 80);
1156 buf += dv_write_dif_id(dv_sect_audio, chan+chan_offset, i, j/15, buf);
1157 buf += 77; /* audio control & shuffled PCM audio */
1158 }
1159 buf += dv_write_dif_id(dv_sect_video, chan+chan_offset, i, j, buf);
1160 buf += 77; /* 1 video macroblock: 1 bytes control
1161 * 4 * 14 bytes Y 8x8 data
1162 * 10 bytes Cr 8x8 data
1163 * 10 bytes Cb 8x8 data */
1164 }
1165 }
1166 }
1167 }
1168
dvvideo_encode_frame(AVCodecContext * c,AVPacket * pkt,const AVFrame * frame,int * got_packet)1169 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
1170 const AVFrame *frame, int *got_packet)
1171 {
1172 DVVideoContext *s = c->priv_data;
1173 int ret;
1174
1175 if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
1176 return ret;
1177
1178 c->pix_fmt = s->sys->pix_fmt;
1179 s->frame = frame;
1180 #if FF_API_CODED_FRAME
1181 FF_DISABLE_DEPRECATION_WARNINGS
1182 c->coded_frame->key_frame = 1;
1183 c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
1184 FF_ENABLE_DEPRECATION_WARNINGS
1185 #endif
1186 s->buf = pkt->data;
1187
1188 dv_format_frame(s, pkt->data);
1189
1190 c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
1191 dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
1192
1193 emms_c();
1194
1195 pkt->flags |= AV_PKT_FLAG_KEY;
1196 *got_packet = 1;
1197
1198 return 0;
1199 }
1200
1201 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
1202 #define OFFSET(x) offsetof(DVVideoContext, x)
1203 static const AVOption dv_options[] = {
1204 { "quant_deadzone", "Quantizer dead zone", OFFSET(quant_deadzone), AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
1205 { NULL },
1206 };
1207
1208 static const AVClass dvvideo_encode_class = {
1209 .class_name = "dvvideo encoder",
1210 .item_name = av_default_item_name,
1211 .option = dv_options,
1212 .version = LIBAVUTIL_VERSION_INT,
1213 };
1214
1215 AVCodec ff_dvvideo_encoder = {
1216 .name = "dvvideo",
1217 .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1218 .type = AVMEDIA_TYPE_VIDEO,
1219 .id = AV_CODEC_ID_DVVIDEO,
1220 .priv_data_size = sizeof(DVVideoContext),
1221 .init = dvvideo_encode_init,
1222 .encode2 = dvvideo_encode_frame,
1223 .capabilities = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS,
1224 .pix_fmts = (const enum AVPixelFormat[]) {
1225 AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
1226 AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
1227 },
1228 .priv_class = &dvvideo_encode_class,
1229 };
1230