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