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                                               int 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                                               int linesize, DVVideoContext *s,
 238                                               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, linesize, y_stride;
 417     uint8_t *y_ptr;
 418     uint8_t *dif;
 419     LOCAL_ALIGNED_8(uint8_t, scratch, [128]);
 420     EncBlockInfo enc_blks[5 * DV_MAX_BPM];
 421     PutBitContext pbs[5 * DV_MAX_BPM];
 422     PutBitContext *pb;
 423     EncBlockInfo *enc_blk;
 424     int vs_bit_size = 0;
 425     int qnos[5] = { 15, 15, 15, 15, 15 }; /* No quantization */
 426     int *qnosp = &qnos[0];
 427
 428     dif     = &s->buf[work_chunk->buf_offset * 80];
 429     enc_blk = &enc_blks[0];
 430     for (mb_index = 0; mb_index < 5; mb_index++) {
 431         dv_calculate_mb_xy(s, work_chunk, mb_index, &mb_x, &mb_y);
 432
 433         /* initializing luminance blocks */
 434         if ((s->sys->pix_fmt == AV_PIX_FMT_YUV420P)                      ||
 435             (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) ||
 436             (s->sys->height >= 720 && mb_y != 134)) {
 437             y_stride = s->frame->linesize[0] << 3;
 438         } else {
 439             y_stride = 16;
 440         }
 441         y_ptr    = s->frame->data[0] +
 442                    ((mb_y * s->frame->linesize[0] + mb_x) << 3);
 443         linesize = s->frame->linesize[0];
 444
 445         if (s->sys->video_stype == 4) { /* SD 422 */
 446             vs_bit_size +=
 447                 dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
 448                 dv_init_enc_block(enc_blk + 1, NULL,                 linesize, s, 0) +
 449                 dv_init_enc_block(enc_blk + 2, y_ptr + 8,            linesize, s, 0) +
 450                 dv_init_enc_block(enc_blk + 3, NULL,                 linesize, s, 0);
 451         } else {
 452             vs_bit_size +=
 453                 dv_init_enc_block(enc_blk + 0, y_ptr,                linesize, s, 0) +
 454                 dv_init_enc_block(enc_blk + 1, y_ptr + 8,            linesize, s, 0) +
 455                 dv_init_enc_block(enc_blk + 2, y_ptr +     y_stride, linesize, s, 0) +
 456                 dv_init_enc_block(enc_blk + 3, y_ptr + 8 + y_stride, linesize, s, 0);
 457         }
 458         enc_blk += 4;
 459
 460         /* initializing chrominance blocks */
 461         c_offset = (((mb_y >>  (s->sys->pix_fmt == AV_PIX_FMT_YUV420P)) * s->frame->linesize[1] +
 462                      (mb_x >> ((s->sys->pix_fmt == AV_PIX_FMT_YUV411P) ? 2 : 1))) << 3);
 463         for (j = 2; j; j--) {
 464             uint8_t *c_ptr = s->frame->data[j] + c_offset;
 465             linesize = s->frame->linesize[j];
 466             y_stride = (mb_y == 134) ? 8 : (s->frame->linesize[j] << 3);
 467             if (s->sys->pix_fmt == AV_PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 468                 uint8_t *d;
 469                 uint8_t *b = scratch;
 470                 for (i = 0; i < 8; i++) {
 471                     d      = c_ptr + (linesize << 3);
 472                     b[0]   = c_ptr[0];
 473                     b[1]   = c_ptr[1];
 474                     b[2]   = c_ptr[2];
 475                     b[3]   = c_ptr[3];
 476                     b[4]   = d[0];
 477                     b[5]   = d[1];
 478                     b[6]   = d[2];
 479                     b[7]   = d[3];
 480                     c_ptr += linesize;
 481                     b     += 16;
 482                 }
 483                 c_ptr    = scratch;
 484                 linesize = 16;
 485             }
 486
 487             vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr, linesize, s, 1);
 488             if (s->sys->bpm == 8)
 489                 vs_bit_size += dv_init_enc_block(enc_blk++, c_ptr + y_stride,
 490                                                  linesize, s, 1);
 491         }
 492     }
 493
 494     if (vs_total_ac_bits < vs_bit_size)
 495         dv_guess_qnos(&enc_blks[0], qnosp);
 496
 497     /* DIF encoding process */
 498     for (j = 0; j < 5 * s->sys->bpm;) {
 499         int start_mb = j;
 500
 501         dif[3] = *qnosp++;
 502         dif   += 4;
 503
 504         /* First pass over individual cells only */
 505         for (i = 0; i < s->sys->bpm; i++, j++) {
 506             int sz = s->sys->block_sizes[i] >> 3;
 507
 508             init_put_bits(&pbs[j], dif, sz);
 509             put_sbits(&pbs[j], 9, ((enc_blks[j].mb[0] >> 3) - 1024 + 2) >> 2);
 510             put_bits(&pbs[j], 1, enc_blks[j].dct_mode);
 511             put_bits(&pbs[j], 2, enc_blks[j].cno);
 512
 513             dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j + 1]);
 514             dif += sz;
 515         }
 516
 517         /* Second pass over each MB space */
 518         pb = &pbs[start_mb];
 519         for (i = 0; i < s->sys->bpm; i++)
 520             if (enc_blks[start_mb + i].partial_bit_count)
 521                 pb = dv_encode_ac(&enc_blks[start_mb + i], pb,
 522                                   &pbs[start_mb + s->sys->bpm]);
 523     }
 524
 525     /* Third and final pass over the whole video segment space */
 526     pb = &pbs[0];
 527     for (j = 0; j < 5 * s->sys->bpm; j++) {
 528         if (enc_blks[j].partial_bit_count)
 529             pb = dv_encode_ac(&enc_blks[j], pb, &pbs[s->sys->bpm * 5]);
 530         if (enc_blks[j].partial_bit_count)
 531             av_log(avctx, AV_LOG_ERROR, "ac bitstream overflow\n");
 532     }
 533
 534     for (j = 0; j < 5 * s->sys->bpm; j++) {
 535         int pos;
 536         int size = pbs[j].size_in_bits >> 3;
 537         flush_put_bits(&pbs[j]);
 538         pos = put_bits_count(&pbs[j]) >> 3;
 539         if (pos > size) {
 540             av_log(avctx, AV_LOG_ERROR,
 541                    "bitstream written beyond buffer size\n");
 542             return -1;
 543         }
 544         memset(pbs[j].buf + pos, 0xff, size - pos);
 545     }
 546
 547     return 0;
 548 }
 549
 550 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c,
 551                                 uint8_t *buf)
 552 {
 553     /*
 554      * Here's what SMPTE314M says about these two:
 555      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
 556      *             as track application IDs (APTn = 001, AP1n =
 557      *             001, AP2n = 001, AP3n = 001), if the source signal
 558      *             comes from a digital VCR. If the signal source is
 559      *             unknown, all bits for these data shall be set to 1.
 560      *    (page 12) STYPE: STYPE defines a signal type of video signal
 561      *                     00000b = 4:1:1 compression
 562      *                     00100b = 4:2:2 compression
 563      *                     XXXXXX = Reserved
 564      * Now, I've got two problems with these statements:
 565      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
 566      *      It seems that for PAL as defined in IEC 61834 we have to set
 567      *      APT to 000 and for SMPTE314M to 001.
 568      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
 569      *      compression scheme (if any).
 570      */
 571     int apt = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
 572
 573     uint8_t aspect = 0;
 574     if ((int) (av_q2d(c->avctx->sample_aspect_ratio) *
 575                c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
 576         aspect = 0x02;
 577
 578     buf[0] = (uint8_t) pack_id;
 579     switch (pack_id) {
 580     case dv_header525: /* I can't imagine why these two weren't defined as real */
 581     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
 582         buf[1] =  0xf8       | /* reserved -- always 1 */
 583                  (apt & 0x07); /* APT: Track application ID */
 584         buf[2] = (0    << 7) | /* TF1: audio data is 0 - valid; 1 - invalid */
 585                  (0x0f << 3) | /* reserved -- always 1 */
 586                  (apt & 0x07); /* AP1: Audio application ID */
 587         buf[3] = (0    << 7) | /* TF2: video data is 0 - valid; 1 - invalid */
 588                  (0x0f << 3) | /* reserved -- always 1 */
 589                  (apt & 0x07); /* AP2: Video application ID */
 590         buf[4] = (0    << 7) | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
 591                  (0x0f << 3) | /* reserved -- always 1 */
 592                  (apt & 0x07); /* AP3: Subcode application ID */
 593         break;
 594     case dv_video_source:
 595         buf[1] = 0xff;         /* reserved -- always 1 */
 596         buf[2] = (1 << 7) |    /* B/W: 0 - b/w, 1 - color */
 597                  (1 << 6) |    /* following CLF is valid - 0, invalid - 1 */
 598                  (3 << 4) |    /* CLF: color frames ID (see ITU-R BT.470-4) */
 599                  0xf;          /* reserved -- always 1 */
 600         buf[3] = (3 << 6)           | /* reserved -- always 1 */
 601                  (c->sys->dsf << 5) | /*  system: 60fields/50fields */
 602                  c->sys->video_stype; /* signal type video compression */
 603         buf[4] = 0xff;         /* VISC: 0xff -- no information */
 604         break;
 605     case dv_video_control:
 606         buf[1] = (0 << 6) |    /* Copy generation management (CGMS) 0 -- free */
 607                  0x3f;         /* reserved -- always 1 */
 608         buf[2] = 0xc8 |        /* reserved -- always b11001xxx */
 609                  aspect;
 610         buf[3] = (1 << 7) |    /* frame/field flag 1 -- frame, 0 -- field */
 611                  (1 << 6) |    /* first/second field flag 0 -- field 2, 1 -- field 1 */
 612                  (1 << 5) |    /* frame change flag 0 -- same picture as before, 1 -- different */
 613                  (1 << 4) |    /* 1 - interlaced, 0 - noninterlaced */
 614                  0xc;          /* reserved -- always b1100 */
 615         buf[4] = 0xff;         /* reserved -- always 1 */
 616         break;
 617     default:
 618         buf[1] =
 619         buf[2] =
 620         buf[3] =
 621         buf[4] = 0xff;
 622     }
 623     return 5;
 624 }
 625
 626 static inline int dv_write_dif_id(enum dv_section_type t, uint8_t chan_num,
 627                                   uint8_t seq_num, uint8_t dif_num,
 628                                   uint8_t *buf)
 629 {
 630     buf[0] = (uint8_t) t;      /* Section type */
 631     buf[1] = (seq_num  << 4) | /* DIF seq number 0-9 for 525/60; 0-11 for 625/50 */
 632              (chan_num << 3) | /* FSC: for 50Mb/s 0 - first channel; 1 - second */
 633              7;                /* reserved -- always 1 */
 634     buf[2] = dif_num;          /* DIF block number Video: 0-134, Audio: 0-8 */
 635     return 3;
 636 }
 637
 638 static inline int dv_write_ssyb_id(uint8_t syb_num, uint8_t fr, uint8_t *buf)
 639 {
 640     if (syb_num == 0 || syb_num == 6) {
 641         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 642                  (0  << 4) | /* AP3 (Subcode application ID) */
 643                  0x0f;       /* reserved -- always 1 */
 644     } else if (syb_num == 11) {
 645         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 646                  0x7f;       /* reserved -- always 1 */
 647     } else {
 648         buf[0] = (fr << 7) | /* FR ID 1 - first half of each channel; 0 - second */
 649                  (0  << 4) | /* APT (Track application ID) */
 650                  0x0f;       /* reserved -- always 1 */
 651     }
 652     buf[1] = 0xf0 |            /* reserved -- always 1 */
 653              (syb_num & 0x0f); /* SSYB number 0 - 11   */
 654     buf[2] = 0xff;             /* reserved -- always 1 */
 655     return 3;
 656 }
 657
 658 static void dv_format_frame(DVVideoContext *c, uint8_t *buf)
 659 {
 660     int chan, i, j, k;
 661
 662     for (chan = 0; chan < c->sys->n_difchan; chan++) {
 663         for (i = 0; i < c->sys->difseg_size; i++) {
 664             memset(buf, 0xff, 80 * 6); /* first 6 DIF blocks are for control data */
 665
 666             /* DV header: 1DIF */
 667             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
 668             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525),
 669                                  c, buf);
 670             buf += 72; /* unused bytes */
 671
 672             /* DV subcode: 2DIFs */
 673             for (j = 0; j < 2; j++) {
 674                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
 675                 for (k = 0; k < 6; k++)
 676                     buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size / 2), buf) + 5;
 677                 buf += 29; /* unused bytes */
 678             }
 679
 680             /* DV VAUX: 3DIFS */
 681             for (j = 0; j < 3; j++) {
 682                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
 683                 buf += dv_write_pack(dv_video_source,  c, buf);
 684                 buf += dv_write_pack(dv_video_control, c, buf);
 685                 buf += 7 * 5;
 686                 buf += dv_write_pack(dv_video_source,  c, buf);
 687                 buf += dv_write_pack(dv_video_control, c, buf);
 688                 buf += 4 * 5 + 2; /* unused bytes */
 689             }
 690
 691             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
 692             for (j = 0; j < 135; j++) {
 693                 if (j % 15 == 0) {
 694                     memset(buf, 0xff, 80);
 695                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j / 15, buf);
 696                     buf += 77; /* audio control & shuffled PCM audio */
 697                 }
 698                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
 699                 buf += 77; /* 1 video macroblock: 1 bytes control
 700                             * 4 * 14 bytes Y 8x8 data
 701                             * 10 bytes Cr 8x8 data
 702                             * 10 bytes Cb 8x8 data */
 703             }
 704         }
 705     }
 706 }
 707
 708 static int dvvideo_encode_frame(AVCodecContext *c, AVPacket *pkt,
 709                                 const AVFrame *frame, int *got_packet)
 710 {
 711     DVVideoContext *s = c->priv_data;
 712     int ret;
 713
 714     if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
 715         av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
 716         return ret;
 717     }
 718
 719     c->pix_fmt                = s->sys->pix_fmt;
 720     s->frame                  = frame;
 721 #if FF_API_CODED_FRAME
 722 FF_DISABLE_DEPRECATION_WARNINGS
 723     c->coded_frame->key_frame = 1;
 724     c->coded_frame->pict_type = AV_PICTURE_TYPE_I;
 725 FF_ENABLE_DEPRECATION_WARNINGS
 726 #endif
 727
 728     s->buf = pkt->data;
 729     c->execute(c, dv_encode_video_segment, s->work_chunks, NULL,
 730                dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
 731
 732     emms_c();
 733
 734     dv_format_frame(s, pkt->data);
 735
 736     pkt->flags |= AV_PKT_FLAG_KEY;
 737     *got_packet = 1;
 738
 739     return 0;
 740 }
 741
 742 AVCodec ff_dvvideo_encoder = {
 743     .name           = "dvvideo",
 744     .long_name      = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
 745     .type           = AVMEDIA_TYPE_VIDEO,
 746     .id             = AV_CODEC_ID_DVVIDEO,
 747     .priv_data_size = sizeof(DVVideoContext),
 748     .init           = dvvideo_encode_init,
 749     .encode2        = dvvideo_encode_frame,
 750     .capabilities   = AV_CODEC_CAP_SLICE_THREADS,
 751     .pix_fmts       = (const enum AVPixelFormat[]) {
 752         AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUV422P,
 753         AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE
 754     },
 755 };