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