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