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