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