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