Merge remote-tracking branch 'qatar/master'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 31 Aug 2011 21:44:21 +0000 (23:44 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 31 Aug 2011 22:01:21 +0000 (00:01 +0200)
* qatar/master: (31 commits)
  libx264: set default thread count to 0 (auto)
  lavc: cosmetics, group deprecated codec flags
  mpeg12: add 'scan_offset' private option.
  h263/p encoder: add 'structured_slices' private option.
  h263/p encoder: add 'obmc' private option.
  h263p encoder: add 'aiv' private option.
  h263p encoder: add 'umv' private option.
  mpeg12enc/mpeg4videoenc: add 'alternate_scan' private option.
  mjpegdec: add 'extern_huff' private option.
  mpeg4enc: add 'data_partitioning' private option.
  snow: add 'memc_only' private option.
  libx264: add 'mbtree' private option.
  libx264: add 'psy' private option.
  libmp3lame: add 'reservoir' private option.
  mpeg2enc: add 'non_linear_quant' private option
  mpeg12enc: add drop_frame_timecode private option.
  mpeg12enc: add intra_vlc private option.
  VC1: Support dynamic dimension changes
  mjpeg: treat external huffman table setup failure as codec init failure if external huffman table use requested
  lavc: deprecate CODEC_FLAG2_BRDO
  ...

Conflicts:
avconv.c
libavcodec/libmp3lame.c
libavcodec/libx264.c
libavcodec/mjpegdec.c
libavcodec/mpeg12enc.c
libavcodec/mpegvideo.h
libavcodec/vc1.c
libavcodec/vc1dec.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
16 files changed:
1  2 
avconv.c
libavcodec/avcodec.h
libavcodec/libmp3lame.c
libavcodec/libx264.c
libavcodec/mjpegdec.c
libavcodec/mjpegdec.h
libavcodec/mpeg12enc.c
libavcodec/mpeg4videoenc.c
libavcodec/mpegvideo.h
libavcodec/mpegvideo_enc.c
libavcodec/mxpegdec.c
libavcodec/options.c
libavcodec/snow.c
libavcodec/vc1.c
libavcodec/vc1dec.c
libavcodec/version.h

diff --cc avconv.c
+++ b/avconv.c
@@@ -204,9 -190,6 +204,8 @@@ static int audio_volume = 256
  static int exit_on_error = 0;
  static int using_stdin = 0;
  static int verbose = 1;
- static int thread_count= 1;
 +static int run_as_daemon  = 0;
 +static int q_pressed = 0;
  static int64_t video_size = 0;
  static int64_t audio_size = 0;
  static int64_t extra_size = 0;
@@@ -2663,19 -2554,9 +2662,9 @@@ static int opt_qscale(const char *opt, 
  static int opt_top_field_first(const char *opt, const char *arg)
  {
      top_field_first = parse_number_or_die(opt, arg, OPT_INT, 0, 1);
 -    return 0;
 +    return opt_default(opt, arg);
  }
  
- static int opt_thread_count(const char *opt, const char *arg)
- {
-     thread_count= parse_number_or_die(opt, arg, OPT_INT64, 0, INT_MAX);
- #if !HAVE_THREADS
-     if (verbose >= 0)
-         fprintf(stderr, "Warning: not compiled with thread support, using thread emulation\n");
- #endif
-     return 0;
- }
  static int opt_audio_sample_fmt(const char *opt, const char *arg)
  {
      if (strcmp(arg, "list")) {
Simple merge
@@@ -35,10 -38,7 +38,11 @@@ typedef struct Mp3AudioContext 
      int stereo;
      uint8_t buffer[BUFFER_SIZE];
      int buffer_index;
 +    struct {
 +        int *left;
 +        int *right;
 +    } s32_data;
+     int reservoir;
  } Mp3AudioContext;
  
  static av_cold int MP3lame_encode_init(AVCodecContext *avctx)
@@@ -277,11 -243,8 +297,12 @@@ AVCodec ff_libmp3lame_encoder = 
      .encode         = MP3lame_encode_frame,
      .close          = MP3lame_encode_close,
      .capabilities= CODEC_CAP_DELAY,
 -    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,AV_SAMPLE_FMT_NONE},
 +    .sample_fmts = (const enum AVSampleFormat[]){AV_SAMPLE_FMT_S16,
 +#if 2147483647 == INT_MAX
 +    AV_SAMPLE_FMT_S32,
 +#endif
 +    AV_SAMPLE_FMT_NONE},
      .supported_samplerates= sSampleRates,
      .long_name= NULL_IF_CONFIG_SMALL("libmp3lame MP3 (MPEG audio layer 3)"),
+     .priv_class     = &libmp3lame_class,
  };
@@@ -301,15 -253,10 +302,14 @@@ static av_cold int X264_init(AVCodecCon
      x4->params.analyse.i_trellis          = avctx->trellis;
      x4->params.analyse.i_noise_reduction  = avctx->noise_reduction;
  
-     x4->params.rc.b_mb_tree               = !!(avctx->flags2 & CODEC_FLAG2_MBTREE);
 -    if (avctx->level > 0)
 -        x4->params.i_level_idc = avctx->level;
 +    x4->params.rc.f_ip_factor             = 1 / fabs(avctx->i_quant_factor);
 +    x4->params.rc.f_pb_factor             = avctx->b_quant_factor;
 +    x4->params.analyse.i_chroma_qp_offset = avctx->chromaoffset;
 +
 +    if (!x4->preset)
 +        check_default_settings(avctx);
  
 -    if (x4->preset || x4->tune)
 +    if (x4->preset || x4->tune) {
          if (x264_param_default_preset(&x4->params, x4->preset, x4->tune) < 0) {
              av_log(avctx, AV_LOG_ERROR, "Error setting preset/tune %s/%s.\n", x4->preset, x4->tune);
              return AVERROR(EINVAL);
      x4->params.p_log_private        = avctx;
      x4->params.i_log_level          = X264_LOG_DEBUG;
  
-     x4->params.b_intra_refresh      = avctx->flags2 & CODEC_FLAG2_INTRA_REFRESH;
 +    OPT_STR("weightp", x4->wpredp);
 +
      if (avctx->bit_rate) {
          x4->params.rc.i_bitrate   = avctx->bit_rate / 1000;
          x4->params.rc.i_rc_method = X264_RC_ABR;
@@@ -480,14 -437,10 +505,14 @@@ static const AVOption options[] = 
      { "tune",          "Tune the encoding params (cf. x264 --fullhelp)",  OFFSET(tune),          FF_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
      { "profile",       "Set profile restrictions (cf. x264 --fullhelp) ", OFFSET(profile),       FF_OPT_TYPE_STRING, { 0 }, 0, 0, VE},
      { "fastfirstpass", "Use fast settings when encoding first pass",      OFFSET(fastfirstpass), FF_OPT_TYPE_INT,    { 1 }, 0, 1, VE},
 +    {"level", "Specify level (as defined by Annex A)", OFFSET(level), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"passlogfile", "Filename for 2 pass stats", OFFSET(stats), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"wpredp", "Weighted prediction for P-frames", OFFSET(wpredp), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
 +    {"x264opts", "x264 options", OFFSET(x264opts), FF_OPT_TYPE_STRING, {.str=NULL}, 0, 0, VE},
      { "crf",           "Select the quality for constant quality mode",    OFFSET(crf),           FF_OPT_TYPE_FLOAT,  {-1 }, -1, FLT_MAX, VE },
      { "crf_max",       "In CRF mode, prevents VBV from lowering quality beyond this point.",OFFSET(crf_max), FF_OPT_TYPE_FLOAT, {-1 }, -1, FLT_MAX, VE },
-     { "cqp",           "Constant quantization parameter rate control method",OFFSET(cqp),        FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE },
-     { "aq_mode",       "AQ method",                                       OFFSET(aq_mode),       FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "aq_mode"},
+     { "qp",            "Constant quantization parameter rate control method",OFFSET(cqp),        FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE },
+     { "aq-mode",       "AQ method",                                       OFFSET(aq_mode),       FF_OPT_TYPE_INT,    {-1 }, -1, INT_MAX, VE, "aq_mode"},
      { "none",          NULL,                              0, FF_OPT_TYPE_CONST, {X264_AQ_NONE},         INT_MIN, INT_MAX, VE, "aq_mode" },
      { "variance",      "Variance AQ (complexity mask)",   0, FF_OPT_TYPE_CONST, {X264_AQ_VARIANCE},     INT_MIN, INT_MAX, VE, "aq_mode" },
      { "autovariance",  "Auto-variance AQ (experimental)", 0, FF_OPT_TYPE_CONST, {X264_AQ_AUTOVARIANCE}, INT_MIN, INT_MAX, VE, "aq_mode" },
@@@ -34,7 -34,7 +34,8 @@@
  #include <assert.h>
  
  #include "libavutil/imgutils.h"
 +#include "libavutil/avassert.h"
+ #include "libavutil/opt.h"
  #include "avcodec.h"
  #include "dsputil.h"
  #include "mjpeg.h"
Simple merge
  #include "mpeg12.h"
  #include "mpeg12data.h"
  #include "bytestream.h"
 -
 +#include "timecode.h"
+ #include "libavutil/log.h"
  #include "libavutil/opt.h"
++#include "libavutil/avassert.h"
  
  static const uint8_t inv_non_linear_qscale[13] = {
      0, 2, 4, 6, 8,
@@@ -174,8 -181,7 +182,8 @@@ static av_cold int encode_init(AVCodecC
          }
      }
  
-     s->tc.drop = !!(avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE);
-     if((avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE) && s->frame_rate_index != 4){
++    s->drop_frame_timecode = s->tc.drop = s->drop_frame_timecode || !!(avctx->flags2 & CODEC_FLAG2_DROP_FRAME_TIMECODE);
+     if (s->drop_frame_timecode && s->frame_rate_index != 4) {
          av_log(avctx, AV_LOG_ERROR, "Drop frame time code only allowed with 1001/30000 fps\n");
          return -1;
      }
@@@ -299,8 -299,13 +307,9 @@@ static void mpeg1_encode_sequence_heade
              time_code = s->current_picture_ptr->f.coded_picture_number + s->avctx->timecode_frame_start;
  
              s->gop_picture_number = s->current_picture_ptr->f.coded_picture_number;
 -            if (s->drop_frame_timecode) {
 -                /* only works for NTSC 29.97 */
 -                int d = time_code / 17982;
 -                int m = time_code % 17982;
 -                //if (m < 2) m += 2; /* not needed since -2,-1 / 1798 in C returns 0 */
 -                time_code += 18 * d + 2 * ((m - 2) / 1798);
 -            }
++            av_assert0(s->drop_frame_timecode == s->tc.drop);
 +            if (s->tc.drop)
 +                time_code = ff_framenum_to_drop_timecode(time_code);
              put_bits(&s->pb, 5, (uint32_t)((time_code / (fps * 3600)) % 24));
              put_bits(&s->pb, 6, (uint32_t)((time_code / (fps * 60)) % 60));
              put_bits(&s->pb, 1, 1);
@@@ -929,17 -934,36 +938,38 @@@ static void mpeg1_encode_block(MpegEncC
      put_bits(&s->pb, table_vlc[112][1], table_vlc[112][0]);
  }
  
- static const AVClass class = {
-     .class_name = "mpegvideo",
-     .item_name  = av_default_item_name,
-     .version    = LIBAVUTIL_VERSION_INT,
-     .option     = (const AVOption[]){
-         {TIMECODE_OPT(MpegEncContext,
-          AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)},
-         {NULL}
-     },
+ #define OFFSET(x) offsetof(MpegEncContext, x)
+ #define VE AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM
+ #define COMMON_OPTS\
++        {TIMECODE_OPT(MpegEncContext,\
++         AV_OPT_FLAG_ENCODING_PARAM | AV_OPT_FLAG_VIDEO_PARAM)},\
+     { "intra_vlc",           "Use MPEG-2 intra VLC table.",       OFFSET(intra_vlc_format),    FF_OPT_TYPE_INT, { 0 }, 0, 1, VE },\
+     { "drop_frame_timecode", "Timecode is in drop frame format.", OFFSET(drop_frame_timecode), FF_OPT_TYPE_INT, { 0 }, 0, 1, VE}, \
+     { "scan_offset",         "Reserve space for SVCD scan offset user data.", OFFSET(scan_offset), FF_OPT_TYPE_INT, { 0 }, 0, 1, VE },
+ static const AVOption mpeg1_options[] = {
+     COMMON_OPTS
+     { NULL },
+ };
+ static const AVOption mpeg2_options[] = {
+     COMMON_OPTS
+     { "non_linear_quant",    "Use nonlinear quantizer.",          OFFSET(q_scale_type),         FF_OPT_TYPE_INT, { 0 }, 0, 1, VE },
+     { "alternate_scan",      "Enable alternate scantable.",       OFFSET(alternate_scan),       FF_OPT_TYPE_INT, { 0 }, 0, 1, VE },
+     { NULL },
  };
  
+ #define mpeg12_class(x)\
+ static const AVClass mpeg## x ##_class = {\
+     .class_name   = "mpeg" #x "video encoder",\
+     .item_name    = av_default_item_name,\
+     .option       = mpeg## x ##_options,\
+     .version      = LIBAVUTIL_VERSION_INT,\
+ };
+ mpeg12_class(1)
+ mpeg12_class(2)
  AVCodec ff_mpeg1video_encoder = {
      .name           = "mpeg1video",
      .type           = AVMEDIA_TYPE_VIDEO,
Simple merge
Simple merge
Simple merge
Simple merge
Simple merge
@@@ -3685,126 -3702,6 +3702,127 @@@ AVCodec ff_snow_encoder = 
      .encode         = encode_frame,
      .close          = encode_end,
      .long_name = NULL_IF_CONFIG_SMALL("Snow"),
+     .priv_class     = &snowenc_class,
  };
  #endif
 +
 +
 +#ifdef TEST
 +#undef malloc
 +#undef free
 +#undef printf
 +
 +#include "libavutil/lfg.h"
 +#include "libavutil/mathematics.h"
 +
 +int main(void){
 +    int width=256;
 +    int height=256;
 +    int buffer[2][width*height];
 +    SnowContext s;
 +    int i;
 +    AVLFG prng;
 +    s.spatial_decomposition_count=6;
 +    s.spatial_decomposition_type=1;
 +
 +    av_lfg_init(&prng, 1);
 +
 +    printf("testing 5/3 DWT\n");
 +    for(i=0; i<width*height; i++)
 +        buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
 +
 +    ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +    ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +
 +    for(i=0; i<width*height; i++)
 +        if(buffer[0][i]!= buffer[1][i]) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
 +
 +    printf("testing 9/7 DWT\n");
 +    s.spatial_decomposition_type=0;
 +    for(i=0; i<width*height; i++)
 +        buffer[0][i] = buffer[1][i] = av_lfg_get(&prng) % 54321 - 12345;
 +
 +    ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +    ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +
 +    for(i=0; i<width*height; i++)
 +        if(FFABS(buffer[0][i] - buffer[1][i])>20) printf("fsck: %6d %12d %7d\n",i, buffer[0][i], buffer[1][i]);
 +
 +    {
 +    int level, orientation, x, y;
 +    int64_t errors[8][4];
 +    int64_t g=0;
 +
 +        memset(errors, 0, sizeof(errors));
 +        s.spatial_decomposition_count=3;
 +        s.spatial_decomposition_type=0;
 +        for(level=0; level<s.spatial_decomposition_count; level++){
 +            for(orientation=level ? 1 : 0; orientation<4; orientation++){
 +                int w= width  >> (s.spatial_decomposition_count-level);
 +                int h= height >> (s.spatial_decomposition_count-level);
 +                int stride= width  << (s.spatial_decomposition_count-level);
 +                DWTELEM *buf= buffer[0];
 +                int64_t error=0;
 +
 +                if(orientation&1) buf+=w;
 +                if(orientation>1) buf+=stride>>1;
 +
 +                memset(buffer[0], 0, sizeof(int)*width*height);
 +                buf[w/2 + h/2*stride]= 256*256;
 +                ff_spatial_idwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +                for(y=0; y<height; y++){
 +                    for(x=0; x<width; x++){
 +                        int64_t d= buffer[0][x + y*width];
 +                        error += d*d;
 +                        if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9 && level==2) printf("%8"PRId64" ", d);
 +                    }
 +                    if(FFABS(height/2-y)<9 && level==2) printf("\n");
 +                }
 +                error= (int)(sqrt(error)+0.5);
 +                errors[level][orientation]= error;
 +                if(g) g=av_gcd(g, error);
 +                else g= error;
 +            }
 +        }
 +        printf("static int const visual_weight[][4]={\n");
 +        for(level=0; level<s.spatial_decomposition_count; level++){
 +            printf("  {");
 +            for(orientation=0; orientation<4; orientation++){
 +                printf("%8"PRId64",", errors[level][orientation]/g);
 +            }
 +            printf("},\n");
 +        }
 +        printf("};\n");
 +        {
 +            int level=2;
 +            int w= width  >> (s.spatial_decomposition_count-level);
 +            //int h= height >> (s.spatial_decomposition_count-level);
 +            int stride= width  << (s.spatial_decomposition_count-level);
 +            DWTELEM *buf= buffer[0];
 +            int64_t error=0;
 +
 +            buf+=w;
 +            buf+=stride>>1;
 +
 +            memset(buffer[0], 0, sizeof(int)*width*height);
 +            for(y=0; y<height; y++){
 +                for(x=0; x<width; x++){
 +                    int tab[4]={0,2,3,1};
 +                    buffer[0][x+width*y]= 256*256*tab[(x&1) + 2*(y&1)];
 +                }
 +            }
 +            ff_spatial_dwt(buffer[0], width, height, width, s.spatial_decomposition_type, s.spatial_decomposition_count);
 +            for(y=0; y<height; y++){
 +                for(x=0; x<width; x++){
 +                    int64_t d= buffer[0][x + y*width];
 +                    error += d*d;
 +                    if(FFABS(width/2-x)<9 && FFABS(height/2-y)<9) printf("%8"PRId64" ", d);
 +                }
 +                if(FFABS(height/2-y)<9) printf("\n");
 +            }
 +        }
 +
 +    }
 +    return 0;
 +}
 +#endif /* TEST */
@@@ -473,12 -469,11 +470,11 @@@ static int decode_sequence_header_adv(V
      }
      v->s.max_b_frames = v->s.avctx->max_b_frames = 7;
      if(get_bits1(gb)) { //Display Info - decoding is not affected by it
 -        int w, h, ar = 0;
 +        int dw, dh, ar = 0;
          av_log(v->s.avctx, AV_LOG_DEBUG, "Display extended info:\n");
-         dw = get_bits(gb, 14) + 1;
-         dh = get_bits(gb, 14) + 1;
-         v->s.avctx->sample_aspect_ratio = av_div_q((AVRational){dw, dh}, (AVRational){w, h});
-         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", dw, dh);
+         w = get_bits(gb, 14) + 1;
+         h = get_bits(gb, 14) + 1;
+         av_log(v->s.avctx, AV_LOG_DEBUG, "Display dimensions: %ix%i\n", w, h);
          if(get_bits1(gb))
              ar = get_bits(gb, 4);
          if(ar && ar < 14){
Simple merge
Simple merge