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