avcodec/vc1: fix calculation of the last line of a slice
[ffmpeg.git] / libavcodec / dvenc.c
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/opt.h"
34 #include "libavutil/pixdesc.h"
35
36 #include "avcodec.h"
37 #include "dv.h"
38 #include "dv_profile_internal.h"
39 #include "dv_tablegen.h"
40 #include "fdctdsp.h"
41 #include "internal.h"
42 #include "mathops.h"
43 #include "me_cmp.h"
44 #include "pixblockdsp.h"
45 #include "put_bits.h"
46
47 static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
48 {
49     DVVideoContext *s = avctx->priv_data;
50     FDCTDSPContext fdsp;
51     MECmpContext mecc;
52     PixblockDSPContext pdsp;
53     int ret;
54
55     s->sys = av_dv_codec_profile2(avctx->width, avctx->height, avctx->pix_fmt, avctx->time_base);
56     if (!s->sys) {
57         av_log(avctx, AV_LOG_ERROR, "Found no DV profile for %ix%i %s video. "
58                                     "Valid DV profiles are:\n",
59                avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
60         ff_dv_print_profiles(avctx, AV_LOG_ERROR);
61         return AVERROR(EINVAL);
62     }
63     if (avctx->height > 576) {
64         av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
65         return AVERROR_PATCHWELCOME;
66     }
67     ret = ff_dv_init_dynamic_tables(s, s->sys);
68     if (ret < 0) {
69         av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
70         return ret;
71     }
72
73     dv_vlc_map_tableinit();
74
75     memset(&fdsp,0, sizeof(fdsp));
76     memset(&mecc,0, sizeof(mecc));
77     memset(&pdsp,0, sizeof(pdsp));
78     ff_fdctdsp_init(&fdsp, avctx);
79     ff_me_cmp_init(&mecc, avctx);
80     ff_pixblockdsp_init(&pdsp, avctx);
81     ff_set_cmp(&mecc, mecc.ildct_cmp, avctx->ildct_cmp);
82
83     s->get_pixels = pdsp.get_pixels;
84     s->ildct_cmp  = mecc.ildct_cmp[5];
85
86     s->fdct[0]    = fdsp.fdct;
87     s->fdct[1]    = fdsp.fdct248;
88
89     return ff_dvvideo_init(avctx);
90 }
91
92 /* bit budget for AC only in 5 MBs */
93 static const int vs_total_ac_bits = (100 * 4 + 68 * 2) * 5;
94 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
95
96 #if CONFIG_SMALL
97 /* Convert run and level (where level != 0) pair into VLC, returning bit size */
98 static av_always_inline int dv_rl2vlc(int run, int level, int sign,
99                                       uint32_t *vlc)
100 {
101     int size;
102     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
103         *vlc = dv_vlc_map[run][level].vlc | sign;
104         size = dv_vlc_map[run][level].size;
105     } else {
106         if (level < DV_VLC_MAP_LEV_SIZE) {
107             *vlc = dv_vlc_map[0][level].vlc | sign;
108             size = dv_vlc_map[0][level].size;
109         } else {
110             *vlc = 0xfe00 | (level << 1) | sign;
111             size = 16;
112         }
113         if (run) {
114             *vlc |= ((run < 16) ? dv_vlc_map[run - 1][0].vlc :
115                      (0x1f80 | (run - 1))) << size;
116             size +=  (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
117         }
118     }
119
120     return size;
121 }
122
123 static av_always_inline int dv_rl2vlc_size(int run, int level)
124 {
125     int size;
126
127     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
128         size = dv_vlc_map[run][level].size;
129     } else {
130         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
131         if (run)
132             size += (run < 16) ? dv_vlc_map[run - 1][0].size : 13;
133     }
134     return size;
135 }
136 #else
137 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t *vlc)
138 {
139     *vlc = dv_vlc_map[run][l].vlc | sign;
140     return dv_vlc_map[run][l].size;
141 }
142
143 static av_always_inline int dv_rl2vlc_size(int run, int l)
144 {
145     return dv_vlc_map[run][l].size;
146 }
147 #endif
148
149 typedef struct EncBlockInfo {
150     int      area_q[4];
151     int      bit_size[4];
152     int      prev[5];
153     int      cur_ac;
154     int      cno;
155     int      dct_mode;
156     int16_t  mb[64];
157     uint8_t  next[64];
158     uint8_t  sign[64];
159     uint8_t  partial_bit_count;
160     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
161 } EncBlockInfo;
162
163 static av_always_inline PutBitContext *dv_encode_ac(EncBlockInfo *bi,
164                                                     PutBitContext *pb_pool,
165                                                     PutBitContext *pb_end)
166 {
167     int prev, bits_left;
168     PutBitContext *pb = pb_pool;
169     int size          = bi->partial_bit_count;
170     uint32_t vlc      = bi->partial_bit_buffer;
171
172     bi->partial_bit_count  =
173     bi->partial_bit_buffer = 0;
174     for (;;) {
175         /* Find suitable storage space */
176         for (; size > (bits_left = put_bits_left(pb)); pb++) {
177             if (bits_left) {
178                 size -= bits_left;
179                 put_bits(pb, bits_left, vlc >> size);
180                 vlc = av_mod_uintp2(vlc, size);
181             }
182             if (pb + 1 >= pb_end) {
183                 bi->partial_bit_count  = size;
184                 bi->partial_bit_buffer = vlc;
185                 return pb;
186             }
187         }
188
189         /* Store VLC */
190         put_bits(pb, size, vlc);
191
192         if (bi->cur_ac >= 64)
193             break;
194
195         /* Construct the next VLC */
196         prev       = bi->cur_ac;
197         bi->cur_ac = bi->next[prev];
198         if (bi->cur_ac < 64) {
199             size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac],
200                              bi->sign[bi->cur_ac], &vlc);
201         } else {
202             size = 4;
203             vlc  = 6; /* End Of Block stamp */
204         }
205     }
206     return pb;
207 }
208
209 static av_always_inline int dv_guess_dct_mode(DVVideoContext *s, uint8_t *data,
210                                               ptrdiff_t linesize)
211 {
212     if (s->avctx->flags & AV_CODEC_FLAG_INTERLACED_DCT) {
213         int ps = s->ildct_cmp(NULL, data, NULL, linesize, 8) - 400;
214         if (ps > 0) {
215             int is = s->ildct_cmp(NULL, data,            NULL, linesize << 1, 4) +
216                      s->ildct_cmp(NULL, data + linesize, NULL, linesize << 1, 4);
217             return ps > is;
218         }
219     }
220
221     return 0;
222 }
223
224 static const int dv_weight_bits = 18;
225 static const int dv_weight_88[64] = {
226     131072, 257107, 257107, 242189, 252167, 242189, 235923, 237536,
227     237536, 235923, 229376, 231390, 223754, 231390, 229376, 222935,
228     224969, 217965, 217965, 224969, 222935, 200636, 218652, 211916,
229     212325, 211916, 218652, 200636, 188995, 196781, 205965, 206433,
230     206433, 205965, 196781, 188995, 185364, 185364, 200636, 200704,
231     200636, 185364, 185364, 174609, 180568, 195068, 195068, 180568,
232     174609, 170091, 175557, 189591, 175557, 170091, 165371, 170627,
233     170627, 165371, 160727, 153560, 160727, 144651, 144651, 136258,
234 };
235 static const int dv_weight_248[64] = {
236     131072, 262144, 257107, 257107, 242189, 242189, 242189, 242189,
237     237536, 237536, 229376, 229376, 200636, 200636, 224973, 224973,
238     223754, 223754, 235923, 235923, 229376, 229376, 217965, 217965,
239     211916, 211916, 196781, 196781, 185364, 185364, 206433, 206433,
240     211916, 211916, 222935, 222935, 200636, 200636, 205964, 205964,
241     200704, 200704, 180568, 180568, 175557, 175557, 195068, 195068,
242     185364, 185364, 188995, 188995, 174606, 174606, 175557, 175557,
243     170627, 170627, 153560, 153560, 165371, 165371, 144651, 144651,
244 };
245
246 static av_always_inline int dv_init_enc_block(EncBlockInfo *bi, uint8_t *data,
247                                               ptrdiff_t linesize,
248                                               DVVideoContext *s, int bias)
249 {
250     const int *weight;
251     const uint8_t *zigzag_scan;
252     LOCAL_ALIGNED_16(int16_t, blk, [64]);
253     int i, area;
254     /* We offer two different methods for class number assignment: the
255      * method suggested in SMPTE 314M Table 22, and an improved
256      * method. The SMPTE method is very conservative; it assigns class
257      * 3 (i.e. severe quantization) to any block where the largest AC
258      * component is greater than 36. FFmpeg's DV encoder tracks AC bit
259      * consumption precisely, so there is no need to bias most blocks
260      * towards strongly lossy compression. Instead, we assign class 2
261      * to most blocks, and use class 3 only when strictly necessary
262      * (for blocks whose largest AC component exceeds 255). */
263
264 #if 0 /* SMPTE spec method */
265     static const int classes[] = { 12, 24, 36, 0xffff };
266 #else /* improved FFmpeg method */
267     static const int classes[] = { -1, -1, 255, 0xffff };
268 #endif
269     int max  = classes[0];
270     int prev = 0;
271     const unsigned deadzone = s->quant_deadzone;
272     const unsigned threshold = 2 * deadzone;
273
274     av_assert2((((int) blk) & 15) == 0);
275
276     bi->area_q[0]          =
277     bi->area_q[1]          =
278     bi->area_q[2]          =
279     bi->area_q[3]          = 0;
280     bi->partial_bit_count  = 0;
281     bi->partial_bit_buffer = 0;
282     bi->cur_ac             = 0;
283     if (data) {
284         bi->dct_mode = dv_guess_dct_mode(s, data, linesize);
285         s->get_pixels(blk, data, linesize);
286         s->fdct[bi->dct_mode](blk);
287     } else {
288         /* We rely on the fact that encoding all zeros leads to an immediate
289          * EOB, which is precisely what the spec calls for in the "dummy"
290          * blocks. */
291         memset(blk, 0, 64 * sizeof(*blk));
292         bi->dct_mode = 0;
293     }
294     bi->mb[0] = blk[0];
295
296     zigzag_scan = bi->dct_mode ? ff_dv_zigzag248_direct : ff_zigzag_direct;
297     weight      = bi->dct_mode ? dv_weight_248 : dv_weight_88;
298
299     for (area = 0; area < 4; area++) {
300         bi->prev[area]     = prev;
301         bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
302         for (i = mb_area_start[area]; i < mb_area_start[area + 1]; i++) {
303             int level = blk[zigzag_scan[i]];
304
305             if (level + deadzone > threshold) {
306                 bi->sign[i] = (level >> 31) & 1;
307                 /* Weight it and shift down into range, adding for rounding.
308                  * The extra division by a factor of 2^4 reverses the 8x
309                  * expansion of the DCT AND the 2x doubling of the weights. */
310                 level     = (FFABS(level) * weight[i] + (1 << (dv_weight_bits + 3))) >>
311                             (dv_weight_bits + 4);
312                 if (!level)
313                     continue;
314                 bi->mb[i] = level;
315                 if (level > max)
316                     max = level;
317                 bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, level);
318                 bi->next[prev]      = i;
319                 prev                = i;
320             }
321         }
322     }
323     bi->next[prev] = i;
324     for (bi->cno = 0; max > classes[bi->cno]; bi->cno++)
325         ;
326
327     bi->cno += bias;
328
329     if (bi->cno >= 3) {
330         bi->cno = 3;
331         prev    = 0;
332         i       = bi->next[prev];
333         for (area = 0; area < 4; area++) {
334             bi->prev[area]     = prev;
335             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
336             for (; i < mb_area_start[area + 1]; i = bi->next[i]) {
337                 bi->mb[i] >>= 1;
338
339                 if (bi->mb[i]) {
340                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
341                     bi->next[prev]      = i;
342                     prev                = i;
343                 }
344             }
345         }
346         bi->next[prev] = i;
347     }
348
349     return bi->bit_size[0] + bi->bit_size[1] +
350            bi->bit_size[2] + bi->bit_size[3];
351 }
352
353 static inline void dv_guess_qnos(EncBlockInfo *blks, int *qnos)
354 {
355     int size[5];
356     int i, j, k, a, prev, a2;
357     EncBlockInfo *b;
358
359     size[0] =
360     size[1] =
361     size[2] =
362     size[3] =
363     size[4] = 1 << 24;
364     do {
365         b = blks;
366         for (i = 0; i < 5; i++) {
367             if (!qnos[i])
368                 continue;
369
370             qnos[i]--;
371             size[i] = 0;
372             for (j = 0; j < 6; j++, b++) {
373                 for (a = 0; a < 4; a++) {
374                     if (b->area_q[a] != ff_dv_quant_shifts[qnos[i] + ff_dv_quant_offset[b->cno]][a]) {
375                         b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
376                         b->area_q[a]++;
377                         prev = b->prev[a];
378                         av_assert2(b->next[prev] >= mb_area_start[a + 1] || b->mb[prev]);
379                         for (k = b->next[prev]; k < mb_area_start[a + 1]; k = b->next[k]) {
380                             b->mb[k] >>= 1;
381                             if (b->mb[k]) {
382                                 b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
383                                 prev            = k;
384                             } else {
385                                 if (b->next[k] >= mb_area_start[a + 1] && b->next[k] < 64) {
386                                     for (a2 = a + 1; b->next[k] >= mb_area_start[a2 + 1]; a2++)
387                                         b->prev[a2] = prev;
388                                     av_assert2(a2 < 4);
389                                     av_assert2(b->mb[b->next[k]]);
390                                     b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]]) -
391                                                        dv_rl2vlc_size(b->next[k] - k    - 1, b->mb[b->next[k]]);
392                                     av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2 + 1] != k));
393                                     b->prev[a2] = prev;
394                                 }
395                                 b->next[prev] = b->next[k];
396                             }
397                         }
398                         b->prev[a + 1] = prev;
399                     }
400                     size[i] += b->bit_size[a];
401                 }
402             }
403             if (vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
404                 return;
405         }
406     } while (qnos[0] | qnos[1] | qnos[2] | qnos[3] | qnos[4]);
407
408     for (a = 2; a == 2 || vs_total_ac_bits < size[0]; a += a) {
409         b       = blks;
410         size[0] = 5 * 6 * 4; // EOB
411         for (j = 0; j < 6 * 5; j++, b++) {
412             prev = b->prev[0];
413             for (k = b->next[prev]; k < 64; k = b->next[k]) {
414                 if (b->mb[k] < a && b->mb[k] > -a) {
415                     b->next[prev] = b->next[k];
416                 } else {
417                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
418                     prev     = k;
419                 }
420             }
421         }
422     }
423 }
424
425 static int dv_encode_video_segment(AVCodecContext *avctx, void *arg)
426 {
427     DVVideoContext *s = avctx->priv_data;
428     DVwork_chunk *work_chunk = arg;
429     int mb_index, i, j;
430     int mb_x, mb_y, c_offset;
431     ptrdiff_t linesize, y_stride;
432     uint8_t *y_ptr;
433     uint8_t *dif;
434     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
435     EncBlockInfo enc_blks[5 * DV_MAX_BPM];
436     PutBitContext pbs[5 * DV_MAX_BPM];
437     PutBitContext *pb;
438     EncBlockInfo *enc_blk;
439     int vs_bit_size = 0;
440     int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
441     int *qnosp = &qnos[0];
442
443     dif     = &s->buf[work_chunk->buf_offset * 80];
444     enc_blk = &enc_blks[0];
445     for (mb_index = 0; mb_index < 5; mb_index++) {
446         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
447
448         /* initializing luminance blocks */
449         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
450             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
451             (s->sys->height >= 720 && mb_y != 134)) {
452             y_stride = s->frame->linesize[0] << 3;
453         } else {
454             y_stride = 16;
455         }
456         y_ptr    = s->frame->data[0] +
457                    ((mb_y * s->frame->linesize[0] + mb_x) << 3);
458         linesize = s->frame->linesize[0];
459
460         if (s->sys->video_stype == 4) { /* SD 422 */
461             vs_bit_size +=
462                 dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
463                 dv_init_enc_block(enc_blk + 1, NULL,                 linesize, s, 0) +
464                 dv_init_enc_block(enc_blk + 2, y_ptr + 8,            linesize, s, 0) +
465                 dv_init_enc_block(enc_blk + 3, NULL,                 linesize, s, 0);
466         } else {
467             vs_bit_size +=
468                 dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
469                 dv_init_enc_block(enc_blk + 1, y_ptr + 8,            linesize, s, 0) +
470                 dv_init_enc_block(enc_blk + 2, y_ptr +     y_stride, linesize, s, 0) +
471                 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
472         }
473         enc_blk += 4;
474
475         /* initializing chrominance blocks */
476         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
477                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
478         for (j = 2; j; j--) {
479             uint8_t *c_ptr = s->frame->data[j] + c_offset;
480             linesize = s->frame->linesize[j];
481             y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
482             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
483                 uint8_t *d;
484                 uint8_t *b = scratch;
485                 for (i = 0; i < 8; i++) {
486                     d      = c_ptr + (linesize << 3);
487                     b[0]   = c_ptr[0];
488                     b[1]   = c_ptr[1];
489                     b[2]   = c_ptr[2];
490                     b[3]   = c_ptr[3];
491                     b[4]   = d[0];
492                     b[5]   = d[1];
493                     b[6]   = d[2];
494                     b[7]   = d[3];
495                     c_ptr += linesize;
496                     b     += 16;
497                 }
498                 c_ptr    = scratch;
499                 linesize = 16;
500             }
501
502             vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
503             if (s->sys->bpm == 8)
504                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
505                                                  linesize, s, 1);
506         }
507     }
508
509     if (vs_total_ac_bits < vs_bit_size)
510         dv_guess_qnos(&enc_blks[0], qnosp);
511
512     /* DIF encoding process */
513     for (j = 0; j < 5 * s->sys->bpm;) {
514         int start_mb = j;
515
516         dif[3] = *qnosp++;
517         dif   += 4;
518
519         /* First pass over individual cells only */
520         for (i = 0; i < s->sys->bpm; i++, j++) {
521             int sz = s->sys->block_sizes[i] >> 3;
522
523             init_put_bits(&pbs[j], dif, sz);
524             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
525             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
526             put_bits(&pbs[j], 2, enc_blks[j].cno);
527
528             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
529             dif += sz;
530         }
531
532         /* Second pass over each MB space */
533         pb = &pbs[start_mb];
534         for (i = 0; i < s->sys->bpm; i++)
535             if (enc_blks[start_mb + i].partial_bit_count)
536                 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
537                                   &pbs[start_mb + s->sys->bpm]);
538     }
539
540     /* Third and final pass over the whole video segment space */
541     pb = &pbs[0];
542     for (j = 0; j < 5 * s->sys->bpm; j++) {
543         if (enc_blks[j].partial_bit_count)
544             pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
545         if (enc_blks[j].partial_bit_count)
546             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
547     }
548
549     for (j = 0; j < 5 * s->sys->bpm; j++) {
550         int pos;
551         int size = pbs[j].size_in_bits >> 3;
552         flush_put_bits(&pbs[j]);
553         pos = put_bits_count(&pbs[j]) >> 3;
554         if (pos > size) {
555             av_log(avctx, AV_LOG_ERROR,
556                    "bitstream written beyond buffer size\n");
557             return -1;
558         }
559         memset(pbs[j].buf + pos, 0xff, size - pos);
560     }
561
562     return 0;
563 }
564
565 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
566                                 uint8_t *buf)
567 {
568     /*
569      * Here's what SMPTE314M says about these two:
570      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
571      *             as track application IDs (APTn = 001, AP1n =
572      *             001, AP2n = 001, AP3n = 001), if the source signal
573      *             comes from a digital VCR. If the signal source is
574      *             unknown, all bits for these data shall be set to 1.
575      *    (page 12) STYPE: STYPE defines a signal type of video signal
576      *                     00000b = 4:1:1 compression
577      *                     00100b = 4:2:2 compression
578      *                     XXXXXX = Reserved
579      * Now, I've got two problems with these statements:
580      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
581      *      It seems that for PAL as defined in IEC 61834 we have to set
582      *      APT to 000 and for SMPTE314M to 001.
583      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
584      *      compression scheme (if any).
585      */
586     int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
587     int fs  = c->frame->top_field_first ? 0x00 : 0x40;
588
589     uint8_t aspect = 0;
590     if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
591                c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
592         aspect = 0x02;
593
594     buf[0] = (uint8_t) pack_id;
595     switch (pack_id) {
596     case dv_header525: /* I can't imagine why these two weren't defined as real */
597     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
598         buf[1] =  0xf8       | /* reserved -- always 1 */
599                  (apt & 0x07); /* APT: Track application ID */
600         buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
601                  (0x0f << 3) | /* reserved -- always 1 */
602                  (apt & 0x07); /* AP1: Audio application ID */
603         buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
604                  (0x0f << 3) | /* reserved -- always 1 */
605                  (apt & 0x07); /* AP2: Video application ID */
606         buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
607                  (0x0f << 3) | /* reserved -- always 1 */
608                  (apt & 0x07); /* AP3: Subcode application ID */
609         break;
610     case dv_video_source:
611         buf[1] = 0xff;         /* reserved -- always 1 */
612         buf[2] = (1 << 7) |    /* B/W: 0 - b/w, 1 - color */
613                  (1 << 6) |    /* following CLF is valid - 0, invalid - 1 */
614                  (3 << 4) |    /* CLF: color frames ID (see ITU-R BT.470-4) */
615                  0xf;          /* reserved -- always 1 */
616         buf[3] = (3 << 6)           | /* reserved -- always 1 */
617                  (c->sys->dsf << 5) | /*  system: 60fields/50fields */
618                  c->sys->video_stype; /* signal type video compression */
619         buf[4] = 0xff;         /* VISC: 0xff -- no information */
620         break;
621     case dv_video_control:
622         buf[1] = (0 << 6) |    /* Copy generation management (CGMS) 0 -- free */
623                  0x3f;         /* reserved -- always 1 */
624         buf[2] = 0xc8 |        /* reserved -- always b11001xxx */
625                  aspect;
626         buf[3] = (1 << 7) |    /* frame/field flag 1 -- frame, 0 -- field */
627                  fs       |    /* first/second field flag 0 -- field 2, 1 -- field 1 */
628                  (1 << 5) |    /* frame change flag 0 -- same picture as before, 1 -- different */
629                  (1 << 4) |    /* 1 - interlaced, 0 - noninterlaced */
630                  0xc;          /* reserved -- always b1100 */
631         buf[4] = 0xff;         /* reserved -- always 1 */
632         break;
633     default:
634         buf[1] =
635         buf[2] =
636         buf[3] =
637         buf[4] = 0xff;
638     }
639     return 5;
640 }
641
642 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
643                                   uint8_t seq_num, uint8_t dif_num,
644                                   uint8_t *buf)
645 {
646     buf[0] = (uint8_t) t;      /* Section type */
647     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
648              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
649              7;                /* reserved -- always 1 */
650     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
651     return 3;
652 }
653
654 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
655 {
656     if (syb_num == 0 || syb_num == 6) {
657         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
658                  (0  << 4) | /* AP3 (Subcode application ID) */
659                  0x0f;       /* reserved -- always 1 */
660     } else if (syb_num == 11) {
661         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
662                  0x7f;       /* reserved -- always 1 */
663     } else {
664         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
665                  (0  << 4) | /* APT (Track application ID) */
666                  0x0f;       /* reserved -- always 1 */
667     }
668     buf[1] = 0xf0 |            /* reserved -- always 1 */
669              (syb_num & 0x0f); /* SSYB number 0 - 11   */
670     buf[2] = 0xff;             /* reserved -- always 1 */
671     return 3;
672 }
673
674 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
675 {
676     int chan, i, j, k;
677
678     for (chan = 0; chan < c->sys->n_difchan; chan++) {
679         for (i = 0; i < c->sys->difseg_size; i++) {
680             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
681
682             /* DV header: 1DIF */
683             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
684             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
685                                  c, buf);
686             buf += 72; /* unused bytes */
687
688             /* DV subcode: 2DIFs */
689             for (j = 0; j < 2; j++) {
690                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
691                 for (k = 0; k < 6; k++)
692                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
693                 buf += 29; /* unused bytes */
694             }
695
696             /* DV VAUX: 3DIFS */
697             for (j = 0; j < 3; j++) {
698                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
699                 buf += dv_write_pack(dv_video_source,  c, buf);
700                 buf += dv_write_pack(dv_video_control, c, buf);
701                 buf += 7 * 5;
702                 buf += dv_write_pack(dv_video_source,  c, buf);
703                 buf += dv_write_pack(dv_video_control, c, buf);
704                 buf += 4 * 5 + 2; /* unused bytes */
705             }
706
707             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
708             for (j = 0; j < 135; j++) {
709                 if (j % 15 == 0) {
710                     memset(buf, 0xff, 80);
711                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
712                     buf += 77; /* audio control & shuffled PCM audio */
713                 }
714                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
715                 buf += 77; /* 1 video macroblock: 1 bytes control
716                             * 4 * 14 bytes Y 8x8 data
717                             * 10 bytes Cr 8x8 data
718                             * 10 bytes Cb 8x8 data */
719             }
720         }
721     }
722 }
723
724 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
725                                 const AVFrame *frame, int *got_packet)
726 {
727     DVVideoContext *s = c->priv_data;
728     int ret;
729
730     if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size, 0)) < 0)
731         return ret;
732
733     c->pix_fmt                = s->sys->pix_fmt;
734     s->frame                  = frame;
735 #if FF_API_CODED_FRAME
736 FF_DISABLE_DEPRECATION_WARNINGS
737     c->coded_frame->key_frame = 1;
738     c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
739 FF_ENABLE_DEPRECATION_WARNINGS
740 #endif
741
742     s->buf = pkt->data;
743     c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
744                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
745
746     emms_c();
747
748     dv_format_frame(s, pkt->data);
749
750     pkt->flags |= AV_PKT_FLAG_KEY;
751     *got_packet = 1;
752
753     return 0;
754 }
755
756 #define VE AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_ENCODING_PARAM
757 #define OFFSET(x) offsetof(DVVideoContext, x)
758 static const AVOption dv_options[] = {
759     { "quant_deadzone",        "Quantizer dead zone",    OFFSET(quant_deadzone),       AV_OPT_TYPE_INT, { .i64 = 7 }, 0, 1024, VE },
760     { NULL },
761 };
762
763 static const AVClass dvvideo_encode_class = {
764     .class_name = "dvvideo encoder",
765     .item_name  = av_default_item_name,
766     .option     = dv_options,
767     .version    = LIBAVUTIL_VERSION_INT,
768 };
769
770 AVCodec ff_dvvideo_encoder = {
771     .name           = "dvvideo",
772     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
773     .type           = AVMEDIA_TYPE_VIDEO,
774     .id             = AV_CODEC_ID_DVVIDEO,
775     .priv_data_size = sizeof(DVVideoContext),
776     .init           = dvvideo_encode_init,
777     .encode2        = dvvideo_encode_frame,
778     .capabilities   = AV_CODEC_CAP_SLICE_THREADS | AV_CODEC_CAP_FRAME_THREADS | AV_CODEC_CAP_INTRA_ONLY,
779     .pix_fmts       = (const enum AVPixelFormat[]) {
780         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
781         AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
782     },
783     .priv_class     = &dvvideo_encode_class,
784 };