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