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