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