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