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