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