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

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