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