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

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