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