git.sesse.net Git - ffmpeg/blob - 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 & 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   = 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 };