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