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