git.sesse.net Git - ffmpeg/blob - libavcodec/dv.c

   1 /*
   2  * DV decoder
   3  * Copyright (c) 2002 Fabrice Bellard.
   4  * Copyright (c) 2004 Roman Shaposhnik.
   5  *
   6  * DV encoder
   7  * Copyright (c) 2003 Roman Shaposhnik.
   8  *
   9  * 50 Mbps (DVCPRO50) support
  10  * Copyright (c) 2006 Daniel Maas <dmaas@maasdigital.com>
  11  *
  12  * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
  13  * of DV technical info.
  14  *
  15  * This file is part of FFmpeg.
  16  *
  17  * FFmpeg is free software; you can redistribute it and/or
  18  * modify it under the terms of the GNU Lesser General Public
  19  * License as published by the Free Software Foundation; either
  20  * version 2.1 of the License, or (at your option) any later version.
  21  *
  22  * FFmpeg is distributed in the hope that it will be useful,
  23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  25  * Lesser General Public License for more details.
  26  *
  27  * You should have received a copy of the GNU Lesser General Public
  28  * License along with FFmpeg; if not, write to the Free Software
  29  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  30  */
  31
  32 /**
  33  * @file dv.c
  34  * DV codec.
  35  */
  36 #define ALT_BITSTREAM_READER
  37 #include "avcodec.h"
  38 #include "dsputil.h"
  39 #include "bitstream.h"
  40 #include "simple_idct.h"
  41 #include "dvdata.h"
  42
  43 //#undef NDEBUG
  44 //#include <assert.h>
  45
  46 typedef struct DVVideoContext {
  47     const DVprofile* sys;
  48     AVFrame picture;
  49     AVCodecContext *avctx;
  50     uint8_t *buf;
  51
  52     uint8_t dv_zigzag[2][64];
  53     uint32_t dv_idct_factor[2][2][22][64];
  54
  55     void (*get_pixels)(DCTELEM *block, const uint8_t *pixels, int line_size);
  56     void (*fdct[2])(DCTELEM *block);
  57     void (*idct_put[2])(uint8_t *dest, int line_size, DCTELEM *block);
  58 } DVVideoContext;
  59
  60 /* MultiThreading - dv_anchor applies to entire DV codec, not just the avcontext */
  61 /* one element is needed for each video segment in a DV frame */
  62 /* at most there are 2 DIF channels * 12 DIF sequences * 27 video segments (PAL 50Mbps) */
  63 #define DV_ANCHOR_SIZE (2*12*27)
  64
  65 static void* dv_anchor[DV_ANCHOR_SIZE];
  66
  67 #define TEX_VLC_BITS 9
  68
  69 #ifdef DV_CODEC_TINY_TARGET
  70 #define DV_VLC_MAP_RUN_SIZE 15
  71 #define DV_VLC_MAP_LEV_SIZE 23
  72 #else
  73 #define DV_VLC_MAP_RUN_SIZE  64
  74 #define DV_VLC_MAP_LEV_SIZE 512 //FIXME sign was removed so this should be /2 but needs check
  75 #endif
  76
  77 /* XXX: also include quantization */
  78 static RL_VLC_ELEM dv_rl_vlc[1184];
  79 /* VLC encoding lookup table */
  80 static struct dv_vlc_pair {
  81    uint32_t vlc;
  82    uint8_t  size;
  83 } dv_vlc_map[DV_VLC_MAP_RUN_SIZE][DV_VLC_MAP_LEV_SIZE];
  84
  85 static void dv_build_unquantize_tables(DVVideoContext *s, uint8_t* perm)
  86 {
  87     int i, q, a;
  88
  89     /* NOTE: max left shift is 6 */
  90     for(q = 0; q < 22; q++) {
  91         /* 88DCT */
  92         i=1;
  93         for(a = 0; a<4; a++) {
  94             for(; i < dv_quant_areas[a]; i++) {
  95                 /* 88 table */
  96                 s->dv_idct_factor[0][0][q][i] = dv_iweight_88[i]<<(dv_quant_shifts[q][a] + 1);
  97                 s->dv_idct_factor[1][0][q][i] = s->dv_idct_factor[0][0][q][i]<<1;
  98
  99                 /* 248 table */
 100                 s->dv_idct_factor[0][1][q][i] = dv_iweight_248[i]<<(dv_quant_shifts[q][a] + 1);
 101                 s->dv_idct_factor[1][1][q][i] = s->dv_idct_factor[0][1][q][i]<<1;
 102             }
 103         }
 104     }
 105 }
 106
 107 static av_cold int dvvideo_init(AVCodecContext *avctx)
 108 {
 109     DVVideoContext *s = avctx->priv_data;
 110     DSPContext dsp;
 111     static int done=0;
 112     int i, j;
 113
 114     if (!done) {
 115         VLC dv_vlc;
 116         uint16_t new_dv_vlc_bits[NB_DV_VLC*2];
 117         uint8_t new_dv_vlc_len[NB_DV_VLC*2];
 118         uint8_t new_dv_vlc_run[NB_DV_VLC*2];
 119         int16_t new_dv_vlc_level[NB_DV_VLC*2];
 120
 121         done = 1;
 122
 123         /* dv_anchor lets each thread know its Id */
 124         for (i=0; i<DV_ANCHOR_SIZE; i++)
 125             dv_anchor[i] = (void*)(size_t)i;
 126
 127         /* it's faster to include sign bit in a generic VLC parsing scheme */
 128         for (i=0, j=0; i<NB_DV_VLC; i++, j++) {
 129             new_dv_vlc_bits[j] = dv_vlc_bits[i];
 130             new_dv_vlc_len[j] = dv_vlc_len[i];
 131             new_dv_vlc_run[j] = dv_vlc_run[i];
 132             new_dv_vlc_level[j] = dv_vlc_level[i];
 133
 134             if (dv_vlc_level[i]) {
 135                 new_dv_vlc_bits[j] <<= 1;
 136                 new_dv_vlc_len[j]++;
 137
 138                 j++;
 139                 new_dv_vlc_bits[j] = (dv_vlc_bits[i] << 1) | 1;
 140                 new_dv_vlc_len[j] = dv_vlc_len[i] + 1;
 141                 new_dv_vlc_run[j] = dv_vlc_run[i];
 142                 new_dv_vlc_level[j] = -dv_vlc_level[i];
 143             }
 144         }
 145
 146         /* NOTE: as a trick, we use the fact the no codes are unused
 147            to accelerate the parsing of partial codes */
 148         init_vlc(&dv_vlc, TEX_VLC_BITS, j,
 149                  new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 150         assert(dv_vlc.table_size == 1184);
 151
 152         for(i = 0; i < dv_vlc.table_size; i++){
 153             int code= dv_vlc.table[i][0];
 154             int len = dv_vlc.table[i][1];
 155             int level, run;
 156
 157             if(len<0){ //more bits needed
 158                 run= 0;
 159                 level= code;
 160             } else {
 161                 run=   new_dv_vlc_run[code] + 1;
 162                 level= new_dv_vlc_level[code];
 163             }
 164             dv_rl_vlc[i].len = len;
 165             dv_rl_vlc[i].level = level;
 166             dv_rl_vlc[i].run = run;
 167         }
 168         free_vlc(&dv_vlc);
 169
 170         for (i = 0; i < NB_DV_VLC - 1; i++) {
 171            if (dv_vlc_run[i] >= DV_VLC_MAP_RUN_SIZE)
 172                continue;
 173 #ifdef DV_CODEC_TINY_TARGET
 174            if (dv_vlc_level[i] >= DV_VLC_MAP_LEV_SIZE)
 175                continue;
 176 #endif
 177
 178            if (dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size != 0)
 179                continue;
 180
 181            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].vlc = dv_vlc_bits[i] <<
 182                                                             (!!dv_vlc_level[i]);
 183            dv_vlc_map[dv_vlc_run[i]][dv_vlc_level[i]].size = dv_vlc_len[i] +
 184                                                              (!!dv_vlc_level[i]);
 185         }
 186         for (i = 0; i < DV_VLC_MAP_RUN_SIZE; i++) {
 187 #ifdef DV_CODEC_TINY_TARGET
 188            for (j = 1; j < DV_VLC_MAP_LEV_SIZE; j++) {
 189               if (dv_vlc_map[i][j].size == 0) {
 190                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 191                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 192                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 193                                           dv_vlc_map[0][j].size;
 194               }
 195            }
 196 #else
 197            for (j = 1; j < DV_VLC_MAP_LEV_SIZE/2; j++) {
 198               if (dv_vlc_map[i][j].size == 0) {
 199                   dv_vlc_map[i][j].vlc = dv_vlc_map[0][j].vlc |
 200                             (dv_vlc_map[i-1][0].vlc << (dv_vlc_map[0][j].size));
 201                   dv_vlc_map[i][j].size = dv_vlc_map[i-1][0].size +
 202                                           dv_vlc_map[0][j].size;
 203               }
 204               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].vlc =
 205                                             dv_vlc_map[i][j].vlc | 1;
 206               dv_vlc_map[i][((uint16_t)(-j))&0x1ff].size =
 207                                             dv_vlc_map[i][j].size;
 208            }
 209 #endif
 210         }
 211     }
 212
 213     /* Generic DSP setup */
 214     dsputil_init(&dsp, avctx);
 215     s->get_pixels = dsp.get_pixels;
 216
 217     /* 88DCT setup */
 218     s->fdct[0] = dsp.fdct;
 219     s->idct_put[0] = dsp.idct_put;
 220     for (i=0; i<64; i++)
 221        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
 222
 223     /* 248DCT setup */
 224     s->fdct[1] = dsp.fdct248;
 225     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
 226     if(avctx->lowres){
 227         for (i=0; i<64; i++){
 228             int j= ff_zigzag248_direct[i];
 229             s->dv_zigzag[1][i] = dsp.idct_permutation[(j&7) + (j&8)*4 + (j&48)/2];
 230         }
 231     }else
 232         memcpy(s->dv_zigzag[1], ff_zigzag248_direct, 64);
 233
 234     /* XXX: do it only for constant case */
 235     dv_build_unquantize_tables(s, dsp.idct_permutation);
 236
 237     avctx->coded_frame = &s->picture;
 238     s->avctx= avctx;
 239
 240     return 0;
 241 }
 242
 243 // #define VLC_DEBUG
 244 // #define printf(...) av_log(NULL, AV_LOG_ERROR, __VA_ARGS__)
 245
 246 typedef struct BlockInfo {
 247     const uint32_t *factor_table;
 248     const uint8_t *scan_table;
 249     uint8_t pos; /* position in block */
 250     uint8_t dct_mode;
 251     uint8_t partial_bit_count;
 252     uint16_t partial_bit_buffer;
 253     int shift_offset;
 254 } BlockInfo;
 255
 256 /* bit budget for AC only in 5 MBs */
 257 static const int vs_total_ac_bits = (100 * 4 + 68*2) * 5;
 258 /* see dv_88_areas and dv_248_areas for details */
 259 static const int mb_area_start[5] = { 1, 6, 21, 43, 64 };
 260
 261 static inline int get_bits_left(GetBitContext *s)
 262 {
 263     return s->size_in_bits - get_bits_count(s);
 264 }
 265
 266 static inline int put_bits_left(PutBitContext* s)
 267 {
 268     return (s->buf_end - s->buf) * 8 - put_bits_count(s);
 269 }
 270
 271 /* decode ac coefs */
 272 static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, DCTELEM *block)
 273 {
 274     int last_index = gb->size_in_bits;
 275     const uint8_t *scan_table = mb->scan_table;
 276     const uint32_t *factor_table = mb->factor_table;
 277     int pos = mb->pos;
 278     int partial_bit_count = mb->partial_bit_count;
 279     int level, run, vlc_len, index;
 280
 281     OPEN_READER(re, gb);
 282     UPDATE_CACHE(re, gb);
 283
 284     /* if we must parse a partial vlc, we do it here */
 285     if (partial_bit_count > 0) {
 286         re_cache = ((unsigned)re_cache >> partial_bit_count) |
 287                    (mb->partial_bit_buffer << (sizeof(re_cache)*8 - partial_bit_count));
 288         re_index -= partial_bit_count;
 289         mb->partial_bit_count = 0;
 290     }
 291
 292     /* get the AC coefficients until last_index is reached */
 293     for(;;) {
 294 #ifdef VLC_DEBUG
 295         printf("%2d: bits=%04x index=%d\n", pos, SHOW_UBITS(re, gb, 16), re_index);
 296 #endif
 297         /* our own optimized GET_RL_VLC */
 298         index = NEG_USR32(re_cache, TEX_VLC_BITS);
 299         vlc_len = dv_rl_vlc[index].len;
 300         if (vlc_len < 0) {
 301             index = NEG_USR32((unsigned)re_cache << TEX_VLC_BITS, -vlc_len) + dv_rl_vlc[index].level;
 302             vlc_len = TEX_VLC_BITS - vlc_len;
 303         }
 304         level = dv_rl_vlc[index].level;
 305         run = dv_rl_vlc[index].run;
 306
 307         /* gotta check if we're still within gb boundaries */
 308         if (re_index + vlc_len > last_index) {
 309             /* should be < 16 bits otherwise a codeword could have been parsed */
 310             mb->partial_bit_count = last_index - re_index;
 311             mb->partial_bit_buffer = NEG_USR32(re_cache, mb->partial_bit_count);
 312             re_index = last_index;
 313             break;
 314         }
 315         re_index += vlc_len;
 316
 317 #ifdef VLC_DEBUG
 318         printf("run=%d level=%d\n", run, level);
 319 #endif
 320         pos += run;
 321         if (pos >= 64)
 322             break;
 323
 324         level = (level*factor_table[pos] + (1 << (dv_iweight_bits-1))) >> dv_iweight_bits;
 325         block[scan_table[pos]] = level;
 326
 327         UPDATE_CACHE(re, gb);
 328     }
 329     CLOSE_READER(re, gb);
 330     mb->pos = pos;
 331 }
 332
 333 static inline void bit_copy(PutBitContext *pb, GetBitContext *gb)
 334 {
 335     int bits_left = get_bits_left(gb);
 336     while (bits_left >= MIN_CACHE_BITS) {
 337         put_bits(pb, MIN_CACHE_BITS, get_bits(gb, MIN_CACHE_BITS));
 338         bits_left -= MIN_CACHE_BITS;
 339     }
 340     if (bits_left > 0) {
 341         put_bits(pb, bits_left, get_bits(gb, bits_left));
 342     }
 343 }
 344
 345 /* mb_x and mb_y are in units of 8 pixels */
 346 static inline void dv_decode_video_segment(DVVideoContext *s,
 347                                            const uint8_t *buf_ptr1,
 348                                            const uint16_t *mb_pos_ptr)
 349 {
 350     int quant, dc, dct_mode, class1, j;
 351     int mb_index, mb_x, mb_y, v, last_index;
 352     DCTELEM *block, *block1;
 353     int c_offset;
 354     uint8_t *y_ptr;
 355     void (*idct_put)(uint8_t *dest, int line_size, DCTELEM *block);
 356     const uint8_t *buf_ptr;
 357     PutBitContext pb, vs_pb;
 358     GetBitContext gb;
 359     BlockInfo mb_data[5 * DV_MAX_BPM], *mb, *mb1;
 360     DECLARE_ALIGNED_16(DCTELEM, sblock[5*DV_MAX_BPM][64]);
 361     DECLARE_ALIGNED_8(uint8_t, mb_bit_buffer[80 + 4]); /* allow some slack */
 362     DECLARE_ALIGNED_8(uint8_t, vs_bit_buffer[5 * 80 + 4]); /* allow some slack */
 363     const int log2_blocksize= 3-s->avctx->lowres;
 364
 365     assert((((int)mb_bit_buffer)&7)==0);
 366     assert((((int)vs_bit_buffer)&7)==0);
 367
 368     memset(sblock, 0, sizeof(sblock));
 369
 370     /* pass 1 : read DC and AC coefficients in blocks */
 371     buf_ptr = buf_ptr1;
 372     block1 = &sblock[0][0];
 373     mb1 = mb_data;
 374     init_put_bits(&vs_pb, vs_bit_buffer, 5 * 80);
 375     for(mb_index = 0; mb_index < 5; mb_index++, mb1 += s->sys->bpm, block1 += s->sys->bpm * 64) {
 376         /* skip header */
 377         quant = buf_ptr[3] & 0x0f;
 378         buf_ptr += 4;
 379         init_put_bits(&pb, mb_bit_buffer, 80);
 380         mb = mb1;
 381         block = block1;
 382         for(j = 0;j < s->sys->bpm; j++) {
 383             last_index = s->sys->block_sizes[j];
 384             init_get_bits(&gb, buf_ptr, last_index);
 385
 386             /* get the dc */
 387             dc = get_sbits(&gb, 9);
 388             dct_mode = get_bits1(&gb);
 389             mb->dct_mode = dct_mode;
 390             mb->scan_table = s->dv_zigzag[dct_mode];
 391             class1 = get_bits(&gb, 2);
 392             mb->factor_table = s->dv_idct_factor[class1 == 3][dct_mode]
 393                 [quant + dv_quant_offset[class1]];
 394             dc = dc << 2;
 395             /* convert to unsigned because 128 is not added in the
 396                standard IDCT */
 397             dc += 1024;
 398             block[0] = dc;
 399             buf_ptr += last_index >> 3;
 400             mb->pos = 0;
 401             mb->partial_bit_count = 0;
 402
 403 #ifdef VLC_DEBUG
 404             printf("MB block: %d, %d ", mb_index, j);
 405 #endif
 406             dv_decode_ac(&gb, mb, block);
 407
 408             /* write the remaining bits  in a new buffer only if the
 409                block is finished */
 410             if (mb->pos >= 64)
 411                 bit_copy(&pb, &gb);
 412
 413             block += 64;
 414             mb++;
 415         }
 416
 417         /* pass 2 : we can do it just after */
 418 #ifdef VLC_DEBUG
 419         printf("***pass 2 size=%d MB#=%d\n", put_bits_count(&pb), mb_index);
 420 #endif
 421         block = block1;
 422         mb = mb1;
 423         init_get_bits(&gb, mb_bit_buffer, put_bits_count(&pb));
 424         flush_put_bits(&pb);
 425         for(j = 0;j < s->sys->bpm; j++, block += 64, mb++) {
 426             if (mb->pos < 64 && get_bits_left(&gb) > 0) {
 427                 dv_decode_ac(&gb, mb, block);
 428                 /* if still not finished, no need to parse other blocks */
 429                 if (mb->pos < 64)
 430                     break;
 431             }
 432         }
 433         /* all blocks are finished, so the extra bytes can be used at
 434            the video segment level */
 435         if (j >= s->sys->bpm)
 436             bit_copy(&vs_pb, &gb);
 437     }
 438
 439     /* we need a pass other the whole video segment */
 440 #ifdef VLC_DEBUG
 441     printf("***pass 3 size=%d\n", put_bits_count(&vs_pb));
 442 #endif
 443     block = &sblock[0][0];
 444     mb = mb_data;
 445     init_get_bits(&gb, vs_bit_buffer, put_bits_count(&vs_pb));
 446     flush_put_bits(&vs_pb);
 447     for(mb_index = 0; mb_index < 5; mb_index++) {
 448         for(j = 0;j < s->sys->bpm; j++) {
 449             if (mb->pos < 64) {
 450 #ifdef VLC_DEBUG
 451                 printf("start %d:%d\n", mb_index, j);
 452 #endif
 453                 dv_decode_ac(&gb, mb, block);
 454             }
 455             if (mb->pos >= 64 && mb->pos < 127)
 456                 av_log(NULL, AV_LOG_ERROR, "AC EOB marker is absent pos=%d\n", mb->pos);
 457             block += 64;
 458             mb++;
 459         }
 460     }
 461
 462     /* compute idct and place blocks */
 463     block = &sblock[0][0];
 464     mb = mb_data;
 465     for(mb_index = 0; mb_index < 5; mb_index++) {
 466         v = *mb_pos_ptr++;
 467         mb_x = v & 0xff;
 468         mb_y = v >> 8;
 469         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<log2_blocksize);
 470         c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 471                      (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<log2_blocksize);
 472
 473         for(j = 0;j < 6; j++) {
 474             idct_put = s->idct_put[mb->dct_mode && log2_blocksize==3];
 475             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 476                 if (j == 0 || j == 2) {
 477                     /* Y0 Y1 */
 478                     idct_put(y_ptr + ((j >> 1)<<log2_blocksize),
 479                              s->picture.linesize[0], block);
 480                 } else if(j > 3) {
 481                     /* Cr Cb */
 482                     idct_put(s->picture.data[6 - j] + c_offset,
 483                              s->picture.linesize[6 - j], block);
 484                 }
 485                 /* note: j=1 and j=3 are "dummy" blocks in 4:2:2 */
 486             } else { /* 4:1:1 or 4:2:0 */
 487                 if (j < 4) {
 488                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 489                         /* NOTE: at end of line, the macroblock is handled as 420 */
 490                         idct_put(y_ptr + (j<<log2_blocksize), s->picture.linesize[0], block);
 491                     } else {
 492                         idct_put(y_ptr + (((j & 1) + (j >> 1) * s->picture.linesize[0])<<log2_blocksize),
 493                                  s->picture.linesize[0], block);
 494                     }
 495                 } else {
 496                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8)) {
 497                         uint64_t aligned_pixels[64/8];
 498                         uint8_t *pixels= (uint8_t*)aligned_pixels;
 499                         uint8_t *c_ptr, *c_ptr1, *ptr, *ptr1;
 500                         int x, y, linesize;
 501                         /* NOTE: at end of line, the macroblock is handled as 420 */
 502                         idct_put(pixels, 8, block);
 503                         linesize = s->picture.linesize[6 - j];
 504                         c_ptr = s->picture.data[6 - j] + c_offset;
 505                         ptr = pixels;
 506                         for(y = 0;y < (1<<log2_blocksize); y++) {
 507                             ptr1= ptr + (1<<(log2_blocksize-1));
 508                             c_ptr1 = c_ptr + (linesize<<log2_blocksize);
 509                             for(x=0; x < (1<<(log2_blocksize-1)); x++){
 510                                 c_ptr[x]= ptr[x]; c_ptr1[x]= ptr1[x];
 511                             }
 512                             c_ptr += linesize;
 513                             ptr += 8;
 514                         }
 515                     } else {
 516                         /* don't ask me why they inverted Cb and Cr ! */
 517                         idct_put(s->picture.data[6 - j] + c_offset,
 518                                  s->picture.linesize[6 - j], block);
 519                     }
 520                 }
 521             }
 522             block += 64;
 523             mb++;
 524         }
 525     }
 526 }
 527
 528 #ifdef DV_CODEC_TINY_TARGET
 529 /* Converts run and level (where level != 0) pair into vlc, returning bit size */
 530 static av_always_inline int dv_rl2vlc(int run, int level, int sign, uint32_t* vlc)
 531 {
 532     int size;
 533     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 534         *vlc = dv_vlc_map[run][level].vlc | sign;
 535         size = dv_vlc_map[run][level].size;
 536     }
 537     else {
 538         if (level < DV_VLC_MAP_LEV_SIZE) {
 539             *vlc = dv_vlc_map[0][level].vlc | sign;
 540             size = dv_vlc_map[0][level].size;
 541         } else {
 542             *vlc = 0xfe00 | (level << 1) | sign;
 543             size = 16;
 544         }
 545         if (run) {
 546             *vlc |= ((run < 16) ? dv_vlc_map[run-1][0].vlc :
 547                                   (0x1f80 | (run - 1))) << size;
 548             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 549         }
 550     }
 551
 552     return size;
 553 }
 554
 555 static av_always_inline int dv_rl2vlc_size(int run, int level)
 556 {
 557     int size;
 558
 559     if (run < DV_VLC_MAP_RUN_SIZE && level < DV_VLC_MAP_LEV_SIZE) {
 560         size = dv_vlc_map[run][level].size;
 561     }
 562     else {
 563         size = (level < DV_VLC_MAP_LEV_SIZE) ? dv_vlc_map[0][level].size : 16;
 564         if (run) {
 565             size += (run < 16) ? dv_vlc_map[run-1][0].size : 13;
 566         }
 567     }
 568     return size;
 569 }
 570 #else
 571 static av_always_inline int dv_rl2vlc(int run, int l, int sign, uint32_t* vlc)
 572 {
 573     *vlc = dv_vlc_map[run][l].vlc | sign;
 574     return dv_vlc_map[run][l].size;
 575 }
 576
 577 static av_always_inline int dv_rl2vlc_size(int run, int l)
 578 {
 579     return dv_vlc_map[run][l].size;
 580 }
 581 #endif
 582
 583 typedef struct EncBlockInfo {
 584     int area_q[4];
 585     int bit_size[4];
 586     int prev[5];
 587     int cur_ac;
 588     int cno;
 589     int dct_mode;
 590     DCTELEM mb[64];
 591     uint8_t next[64];
 592     uint8_t sign[64];
 593     uint8_t partial_bit_count;
 594     uint32_t partial_bit_buffer; /* we can't use uint16_t here */
 595 } EncBlockInfo;
 596
 597 static av_always_inline PutBitContext* dv_encode_ac(EncBlockInfo* bi, PutBitContext* pb_pool,
 598                                        PutBitContext* pb_end)
 599 {
 600     int prev;
 601     int bits_left;
 602     PutBitContext* pb = pb_pool;
 603     int size = bi->partial_bit_count;
 604     uint32_t vlc = bi->partial_bit_buffer;
 605
 606     bi->partial_bit_count = bi->partial_bit_buffer = 0;
 607     for(;;){
 608        /* Find suitable storage space */
 609        for (; size > (bits_left = put_bits_left(pb)); pb++) {
 610           if (bits_left) {
 611               size -= bits_left;
 612               put_bits(pb, bits_left, vlc >> size);
 613               vlc = vlc & ((1<<size)-1);
 614           }
 615           if (pb + 1 >= pb_end) {
 616               bi->partial_bit_count = size;
 617               bi->partial_bit_buffer = vlc;
 618               return pb;
 619           }
 620        }
 621
 622        /* Store VLC */
 623        put_bits(pb, size, vlc);
 624
 625        if(bi->cur_ac>=64)
 626            break;
 627
 628        /* Construct the next VLC */
 629        prev= bi->cur_ac;
 630        bi->cur_ac = bi->next[prev];
 631        if(bi->cur_ac < 64){
 632            size = dv_rl2vlc(bi->cur_ac - prev - 1, bi->mb[bi->cur_ac], bi->sign[bi->cur_ac], &vlc);
 633        } else {
 634            size = 4; vlc = 6; /* End Of Block stamp */
 635        }
 636     }
 637     return pb;
 638 }
 639
 640 static av_always_inline void dv_set_class_number(DCTELEM* blk, EncBlockInfo* bi,
 641                                               const uint8_t* zigzag_scan, const int *weight, int bias)
 642 {
 643     int i, area;
 644     /* We offer two different methods for class number assignment: the
 645        method suggested in SMPTE 314M Table 22, and an improved
 646        method. The SMPTE method is very conservative; it assigns class
 647        3 (i.e. severe quantization) to any block where the largest AC
 648        component is greater than 36. ffmpeg's DV encoder tracks AC bit
 649        consumption precisely, so there is no need to bias most blocks
 650        towards strongly lossy compression. Instead, we assign class 2
 651        to most blocks, and use class 3 only when strictly necessary
 652        (for blocks whose largest AC component exceeds 255). */
 653
 654 #if 0 /* SMPTE spec method */
 655     static const int classes[] = {12, 24, 36, 0xffff};
 656 #else /* improved ffmpeg method */
 657     static const int classes[] = {-1, -1, 255, 0xffff};
 658 #endif
 659     int max=classes[0];
 660     int prev=0;
 661
 662     bi->mb[0] = blk[0];
 663
 664     for (area = 0; area < 4; area++) {
 665        bi->prev[area] = prev;
 666        bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 667        for (i=mb_area_start[area]; i<mb_area_start[area+1]; i++) {
 668           int level = blk[zigzag_scan[i]];
 669
 670           if (level+15 > 30U) {
 671               bi->sign[i] = (level>>31)&1;
 672               /* weigh it and and shift down into range, adding for rounding */
 673               /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
 674                  AND the 2x doubling of the weights */
 675               level = (FFABS(level) * weight[i] + (1<<(dv_weight_bits+3))) >> (dv_weight_bits+4);
 676               bi->mb[i] = level;
 677               if(level>max) max= level;
 678               bi->bit_size[area] += dv_rl2vlc_size(i - prev  - 1, level);
 679               bi->next[prev]= i;
 680               prev= i;
 681           }
 682        }
 683     }
 684     bi->next[prev]= i;
 685     for(bi->cno = 0; max > classes[bi->cno]; bi->cno++);
 686
 687     bi->cno += bias;
 688
 689     if (bi->cno >= 3) {
 690         bi->cno = 3;
 691         prev=0;
 692         i= bi->next[prev];
 693         for (area = 0; area < 4; area++) {
 694             bi->prev[area] = prev;
 695             bi->bit_size[area] = 1; // 4 areas 4 bits for EOB :)
 696             for (; i<mb_area_start[area+1]; i= bi->next[i]) {
 697                 bi->mb[i] >>=1;
 698
 699                 if (bi->mb[i]) {
 700                     bi->bit_size[area] += dv_rl2vlc_size(i - prev - 1, bi->mb[i]);
 701                     bi->next[prev]= i;
 702                     prev= i;
 703                 }
 704             }
 705         }
 706         bi->next[prev]= i;
 707     }
 708 }
 709
 710 //FIXME replace this by dsputil
 711 #define SC(x, y) ((s[x] - s[y]) ^ ((s[x] - s[y]) >> 7))
 712 static av_always_inline int dv_guess_dct_mode(DCTELEM *blk) {
 713     DCTELEM *s;
 714     int score88 = 0;
 715     int score248 = 0;
 716     int i;
 717
 718     /* Compute 8-8 score (small values give a better chance for 8-8 DCT) */
 719     s = blk;
 720     for(i=0; i<7; i++) {
 721         score88 += SC(0,  8) + SC(1, 9) + SC(2, 10) + SC(3, 11) +
 722                    SC(4, 12) + SC(5,13) + SC(6, 14) + SC(7, 15);
 723         s += 8;
 724     }
 725     /* Compute 2-4-8 score (small values give a better chance for 2-4-8 DCT) */
 726     s = blk;
 727     for(i=0; i<6; i++) {
 728         score248 += SC(0, 16) + SC(1,17) + SC(2, 18) + SC(3, 19) +
 729                     SC(4, 20) + SC(5,21) + SC(6, 22) + SC(7, 23);
 730         s += 8;
 731     }
 732
 733     return (score88 - score248 > -10);
 734 }
 735
 736 static inline void dv_guess_qnos(EncBlockInfo* blks, int* qnos)
 737 {
 738     int size[5];
 739     int i, j, k, a, prev, a2;
 740     EncBlockInfo* b;
 741
 742     size[0] = size[1] = size[2] = size[3] = size[4] = 1<<24;
 743     do {
 744        b = blks;
 745        for (i=0; i<5; i++) {
 746           if (!qnos[i])
 747               continue;
 748
 749           qnos[i]--;
 750           size[i] = 0;
 751           for (j=0; j<6; j++, b++) {
 752              for (a=0; a<4; a++) {
 753                 if (b->area_q[a] != dv_quant_shifts[qnos[i] + dv_quant_offset[b->cno]][a]) {
 754                     b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
 755                     b->area_q[a]++;
 756                     prev= b->prev[a];
 757                     assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 758                     for (k= b->next[prev] ; k<mb_area_start[a+1]; k= b->next[k]) {
 759                        b->mb[k] >>= 1;
 760                        if (b->mb[k]) {
 761                            b->bit_size[a] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 762                            prev= k;
 763                        } else {
 764                            if(b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
 765                                 for(a2=a+1; b->next[k] >= mb_area_start[a2+1]; a2++)
 766                                     b->prev[a2] = prev;
 767                                 assert(a2<4);
 768                                 assert(b->mb[b->next[k]]);
 769                                 b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
 770                                                   -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 771                                 assert(b->prev[a2]==k && (a2+1 >= 4 || b->prev[a2+1]!=k));
 772                                 b->prev[a2] = prev;
 773                            }
 774                            b->next[prev] = b->next[k];
 775                        }
 776                     }
 777                     b->prev[a+1]= prev;
 778                 }
 779                 size[i] += b->bit_size[a];
 780              }
 781           }
 782           if(vs_total_ac_bits >= size[0] + size[1] + size[2] + size[3] + size[4])
 783                 return;
 784        }
 785     } while (qnos[0]|qnos[1]|qnos[2]|qnos[3]|qnos[4]);
 786
 787
 788     for(a=2; a==2 || vs_total_ac_bits < size[0]; a+=a){
 789         b = blks;
 790         size[0] = 5*6*4; //EOB
 791         for (j=0; j<6*5; j++, b++) {
 792             prev= b->prev[0];
 793             for (k= b->next[prev]; k<64; k= b->next[k]) {
 794                 if(b->mb[k] < a && b->mb[k] > -a){
 795                     b->next[prev] = b->next[k];
 796                 }else{
 797                     size[0] += dv_rl2vlc_size(k - prev - 1, b->mb[k]);
 798                     prev= k;
 799                 }
 800             }
 801         }
 802     }
 803 }
 804
 805 static inline void dv_encode_video_segment(DVVideoContext *s,
 806                                            uint8_t *dif,
 807                                            const uint16_t *mb_pos_ptr)
 808 {
 809     int mb_index, i, j, v;
 810     int mb_x, mb_y, c_offset, linesize;
 811     uint8_t*  y_ptr;
 812     uint8_t*  data;
 813     uint8_t*  ptr;
 814     int       do_edge_wrap;
 815     DECLARE_ALIGNED_16(DCTELEM, block[64]);
 816     EncBlockInfo  enc_blks[5*6];
 817     PutBitContext pbs[5*6];
 818     PutBitContext* pb;
 819     EncBlockInfo* enc_blk;
 820     int       vs_bit_size = 0;
 821     int       qnos[5];
 822
 823     assert((((int)block) & 15) == 0);
 824
 825     enc_blk = &enc_blks[0];
 826     pb = &pbs[0];
 827     for(mb_index = 0; mb_index < 5; mb_index++) {
 828         v = *mb_pos_ptr++;
 829         mb_x = v & 0xff;
 830         mb_y = v >> 8;
 831         y_ptr = s->picture.data[0] + ((mb_y * s->picture.linesize[0] + mb_x)<<3);
 832         c_offset = (((mb_y>>(s->sys->pix_fmt == PIX_FMT_YUV420P)) * s->picture.linesize[1] +
 833                      (mb_x>>((s->sys->pix_fmt == PIX_FMT_YUV411P)?2:1)))<<3);
 834         do_edge_wrap = 0;
 835         qnos[mb_index] = 15; /* No quantization */
 836         ptr = dif + mb_index*80 + 4;
 837         for(j = 0;j < 6; j++) {
 838             int dummy = 0;
 839             if (s->sys->pix_fmt == PIX_FMT_YUV422P) { /* 4:2:2 */
 840                 if (j == 0 || j == 2) {
 841                     /* Y0 Y1 */
 842                     data = y_ptr + ((j>>1) * 8);
 843                     linesize = s->picture.linesize[0];
 844                 } else if (j > 3) {
 845                     /* Cr Cb */
 846                     data = s->picture.data[6 - j] + c_offset;
 847                     linesize = s->picture.linesize[6 - j];
 848                 } else {
 849                     /* j=1 and j=3 are "dummy" blocks, used for AC data only */
 850                     data = 0;
 851                     linesize = 0;
 852                     dummy = 1;
 853                 }
 854             } else { /* 4:1:1 or 4:2:0 */
 855                 if (j < 4) {  /* Four Y blocks */
 856                     /* NOTE: at end of line, the macroblock is handled as 420 */
 857                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x < (704 / 8)) {
 858                         data = y_ptr + (j * 8);
 859                     } else {
 860                         data = y_ptr + ((j & 1) * 8) + ((j >> 1) * 8 * s->picture.linesize[0]);
 861                     }
 862                     linesize = s->picture.linesize[0];
 863                 } else {      /* Cr and Cb blocks */
 864                     /* don't ask Fabrice why they inverted Cb and Cr ! */
 865                     data = s->picture.data[6 - j] + c_offset;
 866                     linesize = s->picture.linesize[6 - j];
 867                     if (s->sys->pix_fmt == PIX_FMT_YUV411P && mb_x >= (704 / 8))
 868                         do_edge_wrap = 1;
 869                 }
 870             }
 871
 872             /* Everything is set up -- now just copy data -> DCT block */
 873             if (do_edge_wrap) {  /* Edge wrap copy: 4x16 -> 8x8 */
 874                 uint8_t* d;
 875                 DCTELEM *b = block;
 876                 for (i=0;i<8;i++) {
 877                    d = data + 8 * linesize;
 878                    b[0] = data[0]; b[1] = data[1]; b[2] = data[2]; b[3] = data[3];
 879                    b[4] =    d[0]; b[5] =    d[1]; b[6] =    d[2]; b[7] =    d[3];
 880                    data += linesize;
 881                    b += 8;
 882                 }
 883             } else {             /* Simple copy: 8x8 -> 8x8 */
 884                 if (!dummy)
 885                     s->get_pixels(block, data, linesize);
 886             }
 887
 888             if(s->avctx->flags & CODEC_FLAG_INTERLACED_DCT)
 889                 enc_blk->dct_mode = dv_guess_dct_mode(block);
 890             else
 891                 enc_blk->dct_mode = 0;
 892             enc_blk->area_q[0] = enc_blk->area_q[1] = enc_blk->area_q[2] = enc_blk->area_q[3] = 0;
 893             enc_blk->partial_bit_count = 0;
 894             enc_blk->partial_bit_buffer = 0;
 895             enc_blk->cur_ac = 0;
 896
 897             if (dummy) {
 898                 /* We rely on the fact that encoding all zeros leads to an immediate EOB,
 899                    which is precisely what the spec calls for in the "dummy" blocks. */
 900                 memset(block, 0, sizeof(block));
 901             } else {
 902                 s->fdct[enc_blk->dct_mode](block);
 903             }
 904
 905             dv_set_class_number(block, enc_blk,
 906                                 enc_blk->dct_mode ? ff_zigzag248_direct : ff_zigzag_direct,
 907                                 enc_blk->dct_mode ? dv_weight_248 : dv_weight_88,
 908                                 j/4);
 909
 910             init_put_bits(pb, ptr, s->sys->block_sizes[j]/8);
 911             put_bits(pb, 9, (uint16_t)(((enc_blk->mb[0] >> 3) - 1024 + 2) >> 2));
 912             put_bits(pb, 1, enc_blk->dct_mode);
 913             put_bits(pb, 2, enc_blk->cno);
 914
 915             vs_bit_size += enc_blk->bit_size[0] + enc_blk->bit_size[1] +
 916                            enc_blk->bit_size[2] + enc_blk->bit_size[3];
 917             ++enc_blk;
 918             ++pb;
 919             ptr += s->sys->block_sizes[j]/8;
 920         }
 921     }
 922
 923     if (vs_total_ac_bits < vs_bit_size)
 924         dv_guess_qnos(&enc_blks[0], &qnos[0]);
 925
 926     for (i=0; i<5; i++) {
 927        dif[i*80 + 3] = qnos[i];
 928     }
 929
 930     /* First pass over individual cells only */
 931     for (j=0; j<5*6; j++)
 932        dv_encode_ac(&enc_blks[j], &pbs[j], &pbs[j+1]);
 933
 934     /* Second pass over each MB space */
 935     for (j=0; j<5*6; j+=6) {
 936         pb= &pbs[j];
 937         for (i=0; i<6; i++) {
 938             if (enc_blks[i+j].partial_bit_count)
 939                 pb=dv_encode_ac(&enc_blks[i+j], pb, &pbs[j+6]);
 940         }
 941     }
 942
 943     /* Third and final pass over the whole vides segment space */
 944     pb= &pbs[0];
 945     for (j=0; j<5*6; j++) {
 946        if (enc_blks[j].partial_bit_count)
 947            pb=dv_encode_ac(&enc_blks[j], pb, &pbs[6*5]);
 948        if (enc_blks[j].partial_bit_count)
 949             av_log(NULL, AV_LOG_ERROR, "ac bitstream overflow\n");
 950     }
 951
 952     for (j=0; j<5*6; j++)
 953        flush_put_bits(&pbs[j]);
 954 }
 955
 956 static int dv_decode_mt(AVCodecContext *avctx, void* sl)
 957 {
 958     DVVideoContext *s = avctx->priv_data;
 959     int slice = (size_t)sl;
 960
 961     /* which DIF channel is this? */
 962     int chan = slice / (s->sys->difseg_size * 27);
 963
 964     /* slice within the DIF channel */
 965     int chan_slice = slice % (s->sys->difseg_size * 27);
 966
 967     /* byte offset of this channel's data */
 968     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
 969
 970     dv_decode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
 971                             &s->sys->video_place[slice*5]);
 972     return 0;
 973 }
 974
 975 #ifdef CONFIG_DVVIDEO_ENCODER
 976 static int dv_encode_mt(AVCodecContext *avctx, void* sl)
 977 {
 978     DVVideoContext *s = avctx->priv_data;
 979     int slice = (size_t)sl;
 980
 981     /* which DIF channel is this? */
 982     int chan = slice / (s->sys->difseg_size * 27);
 983
 984     /* slice within the DIF channel */
 985     int chan_slice = slice % (s->sys->difseg_size * 27);
 986
 987     /* byte offset of this channel's data */
 988     int chan_offset = chan * s->sys->difseg_size * 150 * 80;
 989
 990     dv_encode_video_segment(s, &s->buf[((chan_slice/27)*6+(chan_slice/3)+chan_slice*5+7)*80 + chan_offset],
 991                             &s->sys->video_place[slice*5]);
 992     return 0;
 993 }
 994 #endif
 995
 996 #ifdef CONFIG_DECODERS
 997 /* NOTE: exactly one frame must be given (120000 bytes for NTSC,
 998    144000 bytes for PAL - or twice those for 50Mbps) */
 999 static int dvvideo_decode_frame(AVCodecContext *avctx,
1000                                  void *data, int *data_size,
1001                                  const uint8_t *buf, int buf_size)
1002 {
1003     DVVideoContext *s = avctx->priv_data;
1004
1005     s->sys = dv_frame_profile(buf);
1006     if (!s->sys || buf_size < s->sys->frame_size)
1007         return -1; /* NOTE: we only accept several full frames */
1008
1009     if(s->picture.data[0])
1010         avctx->release_buffer(avctx, &s->picture);
1011
1012     s->picture.reference = 0;
1013     s->picture.key_frame = 1;
1014     s->picture.pict_type = FF_I_TYPE;
1015     avctx->pix_fmt = s->sys->pix_fmt;
1016     avctx->time_base = (AVRational){s->sys->frame_rate_base, s->sys->frame_rate};
1017     avcodec_set_dimensions(avctx, s->sys->width, s->sys->height);
1018     if(avctx->get_buffer(avctx, &s->picture) < 0) {
1019         av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1020         return -1;
1021     }
1022     s->picture.interlaced_frame = 1;
1023     s->picture.top_field_first = 0;
1024
1025     s->buf = buf;
1026     avctx->execute(avctx, dv_decode_mt, (void**)&dv_anchor[0], NULL,
1027                    s->sys->n_difchan * s->sys->difseg_size * 27);
1028
1029     emms_c();
1030
1031     /* return image */
1032     *data_size = sizeof(AVFrame);
1033     *(AVFrame*)data= s->picture;
1034
1035     return s->sys->frame_size;
1036 }
1037 #endif
1038
1039
1040 static inline int dv_write_pack(enum dv_pack_type pack_id, DVVideoContext *c, uint8_t* buf)
1041 {
1042     /*
1043      * Here's what SMPTE314M says about these two:
1044      *    (page 6) APTn, AP1n, AP2n, AP3n: These data shall be identical
1045      *             as track application IDs (APTn = 001, AP1n =
1046      *             001, AP2n = 001, AP3n = 001), if the source signal
1047      *             comes from a digital VCR. If the signal source is
1048      *             unknown, all bits for these data shall be set to 1.
1049      *    (page 12) STYPE: STYPE defines a signal type of video signal
1050      *                     00000b = 4:1:1 compression
1051      *                     00100b = 4:2:2 compression
1052      *                     XXXXXX = Reserved
1053      * Now, I've got two problems with these statements:
1054      *   1. it looks like APT == 111b should be a safe bet, but it isn't.
1055      *      It seems that for PAL as defined in IEC 61834 we have to set
1056      *      APT to 000 and for SMPTE314M to 001.
1057      *   2. It is not at all clear what STYPE is used for 4:2:0 PAL
1058      *      compression scheme (if any).
1059      */
1060     int apt = (c->sys->pix_fmt == PIX_FMT_YUV420P ? 0 : 1);
1061     int stype = (c->sys->pix_fmt == PIX_FMT_YUV422P ? 4 : 0);
1062
1063     uint8_t aspect = 0;
1064     if((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) == 17) /* 16:9 */
1065         aspect = 0x02;
1066
1067     buf[0] = (uint8_t)pack_id;
1068     switch (pack_id) {
1069     case dv_header525: /* I can't imagine why these two weren't defined as real */
1070     case dv_header625: /* packs in SMPTE314M -- they definitely look like ones */
1071           buf[1] = 0xf8 |               /* reserved -- always 1 */
1072                    (apt & 0x07);        /* APT: Track application ID */
1073           buf[2] = (0 << 7)    | /* TF1: audio data is 0 - valid; 1 - invalid */
1074                    (0x0f << 3) | /* reserved -- always 1 */
1075                    (apt & 0x07); /* AP1: Audio application ID */
1076           buf[3] = (0 << 7)    | /* TF2: video data is 0 - valid; 1 - invalid */
1077                    (0x0f << 3) | /* reserved -- always 1 */
1078                    (apt & 0x07); /* AP2: Video application ID */
1079           buf[4] = (0 << 7)    | /* TF3: subcode(SSYB) is 0 - valid; 1 - invalid */
1080                    (0x0f << 3) | /* reserved -- always 1 */
1081                    (apt & 0x07); /* AP3: Subcode application ID */
1082           break;
1083     case dv_video_source:
1084           buf[1] = 0xff; /* reserved -- always 1 */
1085           buf[2] = (1 << 7) | /* B/W: 0 - b/w, 1 - color */
1086                    (1 << 6) | /* following CLF is valid - 0, invalid - 1 */
1087                    (3 << 4) | /* CLF: color frames id (see ITU-R BT.470-4) */
1088                    0xf; /* reserved -- always 1 */
1089           buf[3] = (3 << 6) | /* reserved -- always 1 */
1090                    (c->sys->dsf << 5) | /*  system: 60fields/50fields */
1091                    stype; /* signal type video compression */
1092           buf[4] = 0xff; /* VISC: 0xff -- no information */
1093           break;
1094     case dv_video_control:
1095           buf[1] = (0 << 6) | /* Copy generation management (CGMS) 0 -- free */
1096                    0x3f; /* reserved -- always 1 */
1097           buf[2] = 0xc8 | /* reserved -- always b11001xxx */
1098                    aspect;
1099           buf[3] = (1 << 7) | /* Frame/field flag 1 -- frame, 0 -- field */
1100                    (1 << 6) | /* First/second field flag 0 -- field 2, 1 -- field 1 */
1101                    (1 << 5) | /* Frame change flag 0 -- same picture as before, 1 -- different */
1102                    (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
1103                    0xc; /* reserved -- always b1100 */
1104           buf[4] = 0xff; /* reserved -- always 1 */
1105           break;
1106     default:
1107           buf[1] = buf[2] = buf[3] = buf[4] = 0xff;
1108     }
1109     return 5;
1110 }
1111
1112 #ifdef CONFIG_DVVIDEO_ENCODER
1113 static void dv_format_frame(DVVideoContext* c, uint8_t* buf)
1114 {
1115     int chan, i, j, k;
1116
1117     for (chan = 0; chan < c->sys->n_difchan; chan++) {
1118         for (i = 0; i < c->sys->difseg_size; i++) {
1119             memset(buf, 0xff, 80 * 6); /* First 6 DIF blocks are for control data */
1120
1121             /* DV header: 1DIF */
1122             buf += dv_write_dif_id(dv_sect_header, chan, i, 0, buf);
1123             buf += dv_write_pack((c->sys->dsf ? dv_header625 : dv_header525), c, buf);
1124             buf += 72; /* unused bytes */
1125
1126             /* DV subcode: 2DIFs */
1127             for (j = 0; j < 2; j++) {
1128                 buf += dv_write_dif_id(dv_sect_subcode, chan, i, j, buf);
1129                 for (k = 0; k < 6; k++)
1130                      buf += dv_write_ssyb_id(k, (i < c->sys->difseg_size/2), buf) + 5;
1131                 buf += 29; /* unused bytes */
1132             }
1133
1134             /* DV VAUX: 3DIFS */
1135             for (j = 0; j < 3; j++) {
1136                 buf += dv_write_dif_id(dv_sect_vaux, chan, i, j, buf);
1137                 buf += dv_write_pack(dv_video_source,  c, buf);
1138                 buf += dv_write_pack(dv_video_control, c, buf);
1139                 buf += 7*5;
1140                 buf += dv_write_pack(dv_video_source,  c, buf);
1141                 buf += dv_write_pack(dv_video_control, c, buf);
1142                 buf += 4*5 + 2; /* unused bytes */
1143             }
1144
1145             /* DV Audio/Video: 135 Video DIFs + 9 Audio DIFs */
1146             for (j = 0; j < 135; j++) {
1147                 if (j%15 == 0) {
1148                     memset(buf, 0xff, 80);
1149                     buf += dv_write_dif_id(dv_sect_audio, chan, i, j/15, buf);
1150                     buf += 77; /* audio control & shuffled PCM audio */
1151                 }
1152                 buf += dv_write_dif_id(dv_sect_video, chan, i, j, buf);
1153                 buf += 77; /* 1 video macro block: 1 bytes control
1154                               4 * 14 bytes Y 8x8 data
1155                               10 bytes Cr 8x8 data
1156                               10 bytes Cb 8x8 data */
1157             }
1158         }
1159     }
1160 }
1161
1162
1163 static int dvvideo_encode_frame(AVCodecContext *c, uint8_t *buf, int buf_size,
1164                                 void *data)
1165 {
1166     DVVideoContext *s = c->priv_data;
1167
1168     s->sys = dv_codec_profile(c);
1169     if (!s->sys)
1170         return -1;
1171     if(buf_size < s->sys->frame_size)
1172         return -1;
1173
1174     c->pix_fmt = s->sys->pix_fmt;
1175     s->picture = *((AVFrame *)data);
1176     s->picture.key_frame = 1;
1177     s->picture.pict_type = FF_I_TYPE;
1178
1179     s->buf = buf;
1180     c->execute(c, dv_encode_mt, (void**)&dv_anchor[0], NULL,
1181                s->sys->n_difchan * s->sys->difseg_size * 27);
1182
1183     emms_c();
1184
1185     dv_format_frame(s, buf);
1186
1187     return s->sys->frame_size;
1188 }
1189 #endif
1190
1191 static int dvvideo_close(AVCodecContext *c)
1192 {
1193     DVVideoContext *s = c->priv_data;
1194
1195     if(s->picture.data[0])
1196         c->release_buffer(c, &s->picture);
1197
1198     return 0;
1199 }
1200
1201
1202 #ifdef CONFIG_DVVIDEO_ENCODER
1203 AVCodec dvvideo_encoder = {
1204     "dvvideo",
1205     CODEC_TYPE_VIDEO,
1206     CODEC_ID_DVVIDEO,
1207     sizeof(DVVideoContext),
1208     dvvideo_init,
1209     dvvideo_encode_frame,
1210     .pix_fmts = (enum PixelFormat[]) {PIX_FMT_YUV411P, PIX_FMT_YUV422P, PIX_FMT_YUV420P, PIX_FMT_NONE},
1211     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1212 };
1213 #endif // CONFIG_DVVIDEO_ENCODER
1214
1215 #ifdef CONFIG_DVVIDEO_DECODER
1216 AVCodec dvvideo_decoder = {
1217     "dvvideo",
1218     CODEC_TYPE_VIDEO,
1219     CODEC_ID_DVVIDEO,
1220     sizeof(DVVideoContext),
1221     dvvideo_init,
1222     NULL,
1223     dvvideo_close,
1224     dvvideo_decode_frame,
1225     CODEC_CAP_DR1,
1226     NULL,
1227     .long_name = NULL_IF_CONFIG_SMALL("DV (Digital Video)"),
1228 };
1229 #endif