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