git.sesse.net Git - ffmpeg/blob - libavcodec/dvenc.c

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