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