Merge commit 'e63b818dbe6060b606ae10eb184859f8b97d2353'
authorMichael Niedermayer <michaelni@gmx.at>
Fri, 27 Jun 2014 17:13:34 +0000 (19:13 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Fri, 27 Jun 2014 17:13:34 +0000 (19:13 +0200)
* commit 'e63b818dbe6060b606ae10eb184859f8b97d2353':
  dv: Properly split decoder and encoder initialization

Conflicts:
libavcodec/dv.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/dv.c
libavcodec/dvdec.c
libavcodec/dvenc.c

diff --combined libavcodec/dv.c
index c3c32864c5a90d4c3e5b767fe229c765d7ba7361,bb1a26970f5a8285e6aa79aca94c8958b47e9a14..745ebfe7c92363196cb77690203ea75879893642
   * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
   * of DV technical info.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -235,7 -235,6 +235,6 @@@ int ff_dv_init_dynamic_tables(DVVideoCo
  av_cold int ff_dvvideo_init(AVCodecContext *avctx)
  {
      DVVideoContext *s = avctx->priv_data;
-     DSPContext dsp;
      static int done = 0;
      int i, j;
  
             to accelerate the parsing of partial codes */
          init_vlc(&dv_vlc, TEX_VLC_BITS, j,
                   new_dv_vlc_len, 1, 1, new_dv_vlc_bits, 2, 2, 0);
 -        assert(dv_vlc.table_size == 1184);
 +        av_assert1(dv_vlc.table_size == 1184);
  
          for (i = 0; i < dv_vlc.table_size; i++){
              int code = dv_vlc.table[i][0];
          ff_free_vlc(&dv_vlc);
      }
  
-     /* Generic DSP setup */
-     memset(&dsp,0, sizeof(dsp));
-     ff_dsputil_init(&dsp, avctx);
-     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
-     s->get_pixels = dsp.get_pixels;
-     s->ildct_cmp = dsp.ildct_cmp[5];
-     /* 88DCT setup */
-     s->fdct[0]     = dsp.fdct;
-     s->idct_put[0] = dsp.idct_put;
-     for (i = 0; i < 64; i++)
-        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
-     /* 248DCT setup */
-     s->fdct[1]     = dsp.fdct248;
-     s->idct_put[1] = ff_simple_idct248_put;  // FIXME: need to add it to DSP
-     if (avctx->lowres){
-         for (i = 0; i < 64; i++){
-             int j = ff_dv_zigzag248_direct[i];
-             s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
-         }
-     }else
-         memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
      s->avctx = avctx;
      avctx->chroma_sample_location = AVCHROMA_LOC_TOPLEFT;
  
      return 0;
  }
 +
diff --combined libavcodec/dvdec.c
index d7aaa5f0f25fcc5b2be7bd7c8042077b3a0c01ca,9a559dbd45a8815c72e57b709a3746469cb22e33..bf8b5b57e2e18d20e1e201d9d41e664fea2d246b
   * Many thanks to Dan Dennedy <dan@dennedy.org> for providing wealth
   * of DV technical info.
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -35,7 -35,6 +35,7 @@@
   * DV decoder
   */
  
 +#include "libavutil/avassert.h"
  #include "libavutil/internal.h"
  #include "libavutil/imgutils.h"
  #include "libavutil/pixdesc.h"
@@@ -59,6 -58,25 +59,32 @@@ typedef struct BlockInfo 
  
  static const int dv_iweight_bits = 14;
  
 -    memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
+ static av_cold int dvvideo_decode_init(AVCodecContext *avctx)
+ {
+     DVVideoContext *s = avctx->priv_data;
+     DSPContext dsp;
+     int i;
++    memset(&dsp,0, sizeof(dsp));
+     ff_dsputil_init(&dsp, avctx);
+     for (i = 0; i < 64; i++)
+        s->dv_zigzag[0][i] = dsp.idct_permutation[ff_zigzag_direct[i]];
++    if (avctx->lowres){
++        for (i = 0; i < 64; i++){
++            int j = ff_dv_zigzag248_direct[i];
++            s->dv_zigzag[1][i] = dsp.idct_permutation[(j & 7) + (j & 8) * 4 + (j & 48) / 2];
++        }
++    }else
++        memcpy(s->dv_zigzag[1], ff_dv_zigzag248_direct, sizeof(s->dv_zigzag[1]));
+     s->idct_put[0] = dsp.idct_put;
+     s->idct_put[1] = ff_simple_idct248_put;
+     return ff_dvvideo_init(avctx);
+ }
  /* decode AC coefficients */
  static void dv_decode_ac(GetBitContext *gb, BlockInfo *mb, int16_t *block)
  {
@@@ -148,11 -166,11 +174,11 @@@ static int dv_decode_video_segment(AVCo
      LOCAL_ALIGNED_16(int16_t, sblock, [5*DV_MAX_BPM], [64]);
      LOCAL_ALIGNED_16(uint8_t, mb_bit_buffer, [  80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
      LOCAL_ALIGNED_16(uint8_t, vs_bit_buffer, [5*80 + FF_INPUT_BUFFER_PADDING_SIZE]); /* allow some slack */
 -    const int log2_blocksize = 3;
 +    const int log2_blocksize = 3-s->avctx->lowres;
      int is_field_mode[5];
  
 -    assert((((int)mb_bit_buffer) & 7) == 0);
 -    assert((((int)vs_bit_buffer) & 7) == 0);
 +    av_assert1((((int)mb_bit_buffer) & 7) == 0);
 +    av_assert1((((int)vs_bit_buffer) & 7) == 0);
  
      memset(sblock, 0, 5*DV_MAX_BPM*sizeof(*sblock));
  
      flush_put_bits(&vs_pb);
      for (mb_index = 0; mb_index < 5; mb_index++) {
          for (j = 0; j < s->sys->bpm; j++) {
 -            if (mb->pos < 64) {
 +            if (mb->pos < 64 && get_bits_left(&gb) > 0) {
                  av_dlog(avctx, "start %d:%d\n", mb_index, j);
                  dv_decode_ac(&gb, mb, block);
              }
                    int x, y;
                    mb->idct_put(pixels, 8, block);
                    for (y = 0; y < (1 << log2_blocksize); y++, c_ptr += s->frame->linesize[j], pixels += 8) {
 -                      ptr1   = pixels + (1 << (log2_blocksize - 1));
 +                      ptr1   = pixels + ((1 << (log2_blocksize))>>1);
                        c_ptr1 = c_ptr + (s->frame->linesize[j] << log2_blocksize);
 -                      for (x = 0; x < (1 << (log2_blocksize - 1)); x++) {
 +                      for (x = 0; x < (1 << FFMAX(log2_blocksize - 1, 0)); x++) {
                            c_ptr[x]  = pixels[x];
                            c_ptr1[x] = ptr1[x];
                        }
@@@ -324,7 -342,7 +350,7 @@@ static int dvvideo_decode_frame(AVCodec
      int apt, is16_9, ret;
      const DVprofile *sys;
  
 -    sys = avpriv_dv_frame_profile(s->sys, buf, buf_size);
 +    sys = avpriv_dv_frame_profile2(avctx, s->sys, buf, buf_size);
      if (!sys || buf_size < sys->frame_size) {
          av_log(avctx, AV_LOG_ERROR, "could not find dv frame profile\n");
          return -1; /* NOTE: we only accept several full frames */
          ff_set_sar(avctx, s->sys->sar[is16_9]);
      }
  
 -    if (ff_get_buffer(avctx, s->frame, 0) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
 -        return -1;
 -    }
 +    if ((ret = ff_get_buffer(avctx, s->frame, 0)) < 0)
 +        return ret;
      s->frame->interlaced_frame = 1;
      s->frame->top_field_first  = 0;
  
 +    /* Determine the codec's field order from the packet */
 +    if ( *vsc_pack == dv_video_control ) {
 +        s->frame->top_field_first = !(vsc_pack[3] & 0x40);
 +    }
 +
      s->buf = buf;
      avctx->execute(avctx, dv_decode_video_segment, s->work_chunks, NULL,
                     dv_work_pool_size(s->sys), sizeof(DVwork_chunk));
@@@ -385,8 -400,7 +411,8 @@@ AVCodec ff_dvvideo_decoder = 
      .type           = AVMEDIA_TYPE_VIDEO,
      .id             = AV_CODEC_ID_DVVIDEO,
      .priv_data_size = sizeof(DVVideoContext),
-     .init           = ff_dvvideo_init,
+     .init           = dvvideo_decode_init,
      .decode         = dvvideo_decode_frame,
      .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_SLICE_THREADS,
 +    .max_lowres     = 3,
  };
diff --combined libavcodec/dvenc.c
index 4a1103860db26fbbfafc8aee1586325640247677,5b013adf51fc61acf139b05b2d2cf87e4687fe23..d1e7707b0261b40544b9c9c4a31c551657b3182c
@@@ -2,20 -2,20 +2,20 @@@
   * DV encoder
   * Copyright (c) 2003 Roman Shaposhnik
   *
 - * This file is part of Libav.
 + * This file is part of FFmpeg.
   *
 - * Libav is free software; you can redistribute it and/or
 + * FFmpeg is free software; you can redistribute it and/or
   * modify it under the terms of the GNU Lesser General Public
   * License as published by the Free Software Foundation; either
   * version 2.1 of the License, or (at your option) any later version.
   *
 - * Libav is distributed in the hope that it will be useful,
 + * FFmpeg is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   * Lesser General Public License for more details.
   *
   * You should have received a copy of the GNU Lesser General Public
 - * License along with Libav; if not, write to the Free Software
 + * License along with FFmpeg; if not, write to the Free Software
   * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
   */
  
@@@ -28,6 -28,7 +28,7 @@@
  #include "libavutil/pixdesc.h"
  #include "config.h"
  #include "avcodec.h"
+ #include "dsputil.h"
  #include "internal.h"
  #include "put_bits.h"
  #include "dv.h"
@@@ -36,6 -37,7 +37,7 @@@
  static av_cold int dvvideo_encode_init(AVCodecContext *avctx)
  {
      DVVideoContext *s = avctx->priv_data;
+     DSPContext dsp;
      int ret;
  
      s->sys = avpriv_dv_codec_profile(avctx);
          ff_dv_print_profiles(avctx, AV_LOG_ERROR);
          return AVERROR(EINVAL);
      }
 +    if (avctx->height > 576) {
 +        av_log(avctx, AV_LOG_ERROR, "DVCPRO HD encoding is not supported.\n");
 +        return AVERROR_PATCHWELCOME;
 +    }
      ret = ff_dv_init_dynamic_tables(s, s->sys);
      if (ret < 0) {
          av_log(avctx, AV_LOG_ERROR, "Error initializing work tables.\n");
  
      dv_vlc_map_tableinit();
  
++    memset(&dsp,0, sizeof(dsp));
+     ff_dsputil_init(&dsp, avctx);
+     ff_set_cmp(&dsp, dsp.ildct_cmp, avctx->ildct_cmp);
+     s->get_pixels = dsp.get_pixels;
+     s->ildct_cmp  = dsp.ildct_cmp[5];
+     s->fdct[0]    = dsp.fdct;
+     s->fdct[1]    = dsp.fdct248;
      return ff_dvvideo_init(avctx);
  }
  
@@@ -226,7 -233,7 +238,7 @@@ static av_always_inline int dv_init_enc
         method suggested in SMPTE 314M Table 22, and an improved
         method. The SMPTE method is very conservative; it assigns class
         3 (i.e. severe quantization) to any block where the largest AC
 -       component is greater than 36. Libav's DV encoder tracks AC bit
 +       component is greater than 36. FFmpeg's DV encoder tracks AC bit
         consumption precisely, so there is no need to bias most blocks
         towards strongly lossy compression. Instead, we assign class 2
         to most blocks, and use class 3 only when strictly necessary
  
  #if 0 /* SMPTE spec method */
      static const int classes[] = {12, 24, 36, 0xffff};
 -#else /* improved Libav method */
 +#else /* improved FFmpeg method */
      static const int classes[] = {-1, -1, 255, 0xffff};
  #endif
      int max  = classes[0];
      int prev = 0;
  
 -    assert((((int)blk) & 15) == 0);
 +    av_assert2((((int)blk) & 15) == 0);
  
      bi->area_q[0] = bi->area_q[1] = bi->area_q[2] = bi->area_q[3] = 0;
      bi->partial_bit_count = 0;
  
            if (level + 15 > 30U) {
                bi->sign[i] = (level >> 31) & 1;
 -              /* weight it and and shift down into range, adding for rounding */
 +              /* weight it and shift down into range, adding for rounding */
                /* the extra division by a factor of 2^4 reverses the 8x expansion of the DCT
                   AND the 2x doubling of the weights */
                level = (FFABS(level) * weight[i] + (1 << (dv_weight_bits+3))) >> (dv_weight_bits+4);
@@@ -331,7 -338,7 +343,7 @@@ static inline void dv_guess_qnos(EncBlo
                      b->bit_size[a] = 1; // 4 areas 4 bits for EOB :)
                      b->area_q[a]++;
                      prev = b->prev[a];
 -                    assert(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
 +                    av_assert2(b->next[prev] >= mb_area_start[a+1] || b->mb[prev]);
                      for (k = b->next[prev] ; k < mb_area_start[a+1]; k = b->next[k]) {
                         b->mb[k] >>= 1;
                         if (b->mb[k]) {
                             if (b->next[k] >= mb_area_start[a+1] && b->next[k]<64){
                                  for (a2 = a + 1; b->next[k] >= mb_area_start[a2+1]; a2++)
                                      b->prev[a2] = prev;
 -                                assert(a2 < 4);
 -                                assert(b->mb[b->next[k]]);
 +                                av_assert2(a2 < 4);
 +                                av_assert2(b->mb[b->next[k]]);
                                  b->bit_size[a2] += dv_rl2vlc_size(b->next[k] - prev - 1, b->mb[b->next[k]])
                                                    -dv_rl2vlc_size(b->next[k] -    k - 1, b->mb[b->next[k]]);
 -                                assert(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
 +                                av_assert2(b->prev[a2] == k && (a2 + 1 >= 4 || b->prev[a2+1] != k));
                                  b->prev[a2] = prev;
                             }
                             b->next[prev] = b->next[k];
@@@ -532,7 -539,6 +544,7 @@@ static inline int dv_write_pack(enum dv
       *      compression scheme (if any).
       */
      int apt   = (c->sys->pix_fmt == AV_PIX_FMT_YUV420P ? 0 : 1);
 +    int fs    = c->frame->top_field_first ? 0x00 : 0x40;
  
      uint8_t aspect = 0;
      if ((int)(av_q2d(c->avctx->sample_aspect_ratio) * c->avctx->width / c->avctx->height * 10) >= 17) /* 16:9 */
            buf[2] = 0xc8 |     /* reserved -- always b11001xxx */
                     aspect;
            buf[3] = (1 << 7) | /* frame/field flag 1 -- frame, 0 -- field */
 -                   (1 << 6) | /* first/second field flag 0 -- field 2, 1 -- field 1 */
 +                   fs       | /* first/second field flag 0 -- field 2, 1 -- field 1 */
                     (1 << 5) | /* frame change flag 0 -- same picture as before, 1 -- different */
                     (1 << 4) | /* 1 - interlaced, 0 - noninterlaced */
                     0xc;       /* reserved -- always b1100 */
@@@ -674,8 -680,10 +686,8 @@@ static int dvvideo_encode_frame(AVCodec
      DVVideoContext *s = c->priv_data;
      int ret;
  
 -    if ((ret = ff_alloc_packet(pkt, s->sys->frame_size)) < 0) {
 -        av_log(c, AV_LOG_ERROR, "Error getting output packet.\n");
 +    if ((ret = ff_alloc_packet2(c, pkt, s->sys->frame_size)) < 0)
          return ret;
 -    }
  
      c->pix_fmt                = s->sys->pix_fmt;
      s->frame                  = frame;