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