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