Merge commit '0a024268261d05ccdcf7e03c85fb78d22037a464'
authorMichael Niedermayer <michaelni@gmx.at>
Tue, 26 Aug 2014 19:45:39 +0000 (21:45 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Tue, 26 Aug 2014 19:45:39 +0000 (21:45 +0200)
* commit '0a024268261d05ccdcf7e03c85fb78d22037a464':
  libxvid: K&R formatting cosmetics

Conflicts:
libavcodec/libxvid.c
libavcodec/libxvid_rc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/libxvid.c
libavcodec/libxvid.h
libavcodec/libxvid_rc.c
libavutil/file.c

   * @author Adam Thayer (krevnik@comcast.net)
   */
  
 -#include <unistd.h>
  #include <xvid.h>
- #include "avcodec.h"
- #include "internal.h"
- #include "libavutil/file.h"
  #include "libavutil/cpu.h"
++#include "libavutil/file.h"
  #include "libavutil/intreadwrite.h"
  #include "libavutil/mathematics.h"
+ #include "avcodec.h"
++#include "internal.h"
  #include "libxvid.h"
  #include "mpegvideo.h"
  
@@@ -117,12 -107,12 +119,12 @@@ static int xvid_ff_2pass_create(xvid_pl
      /* This is because we can safely prevent a buffer overflow */
      log[0] = 0;
      snprintf(log, BUFFER_REMAINING(log),
-         "# ffmpeg 2-pass log file, using xvid codec\n");
 -             "# avconv 2-pass log file, using xvid codec\n");
++             "# ffmpeg 2-pass log file, using xvid codec\n");
      snprintf(BUFFER_CAT(log), BUFFER_REMAINING(log),
-         "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
-         XVID_VERSION_MAJOR(XVID_VERSION),
-         XVID_VERSION_MINOR(XVID_VERSION),
-         XVID_VERSION_PATCH(XVID_VERSION));
+              "# Do not modify. libxvidcore version: %d.%d.%d\n\n",
+              XVID_VERSION_MAJOR(XVID_VERSION),
+              XVID_VERSION_MINOR(XVID_VERSION),
+              XVID_VERSION_PATCH(XVID_VERSION));
  
      *handle = x->context;
      return 0;
@@@ -364,28 -353,26 +365,28 @@@ static av_cold int xvid_encode_init(AVC
      uint16_t *intra, *inter;
      int fd;
  
 -    xvid_plugin_single_t single         = { 0 };
 -    struct xvid_ff_pass1 rc2pass1       = { 0 };
 -    xvid_plugin_2pass2_t rc2pass2       = { 0 };
 -    xvid_plugin_lumimasking_t masking_l = { 0 }; /* For lumi masking */
 -    xvid_plugin_lumimasking_t masking_v = { 0 }; /* For variance AQ */
 -    xvid_plugin_ssim_t ssim             = { 0 };
 -    xvid_gbl_init_t xvid_gbl_init       = { 0 };
 -    xvid_enc_create_t xvid_enc_create   = { 0 };
 -    xvid_enc_plugin_t plugins[7];
 -
 -    /* Bring in VOP flags from avconv command-line */
 -    x->vop_flags = XVID_VOP_HALFPEL; /* Bare minimum quality */
 +    xvid_plugin_single_t      single          = { 0 };
 +    struct xvid_ff_pass1      rc2pass1        = { 0 };
 +    xvid_plugin_2pass2_t      rc2pass2        = { 0 };
 +    xvid_plugin_lumimasking_t masking_l       = { 0 }; /* For lumi masking */
 +    xvid_plugin_lumimasking_t masking_v       = { 0 }; /* For variance AQ */
 +    xvid_plugin_ssim_t        ssim            = { 0 };
 +    xvid_gbl_init_t           xvid_gbl_init   = { 0 };
 +    xvid_enc_create_t         xvid_enc_create = { 0 };
 +    xvid_enc_plugin_t         plugins[4];
 +
 +    x->twopassfd = -1;
 +
 +    /* Bring in VOP flags from ffmpeg command-line */
 +    x->vop_flags = XVID_VOP_HALFPEL;              /* Bare minimum quality */
-     if( xvid_flags & CODEC_FLAG_4MV )
+     if (xvid_flags & CODEC_FLAG_4MV)
 -        x->vop_flags |= XVID_VOP_INTER4V; /* Level 3 */
 +        x->vop_flags    |= XVID_VOP_INTER4V;      /* Level 3 */
-     ifavctx->trellis)
+     if (avctx->trellis)
 -        x->vop_flags |= XVID_VOP_TRELLISQUANT; /* Level 5 */
 +        x->vop_flags    |= XVID_VOP_TRELLISQUANT; /* Level 5 */
-     if( xvid_flags & CODEC_FLAG_AC_PRED )
+     if (xvid_flags & CODEC_FLAG_AC_PRED)
 -        x->vop_flags |= XVID_VOP_HQACPRED; /* Level 6 */
 +        x->vop_flags    |= XVID_VOP_HQACPRED;     /* Level 6 */
-     if( xvid_flags & CODEC_FLAG_GRAY )
+     if (xvid_flags & CODEC_FLAG_GRAY)
 -        x->vop_flags |= XVID_VOP_GREYSCALE;
 +        x->vop_flags    |= XVID_VOP_GREYSCALE;
  
      /* Decide which ME quality setting to use */
      x->me_flags = 0;
      }
  
      /* Decide how we should decide blocks */
-     switch( avctx->mb_decision ) {
-        case 2:
-            x->vop_flags |= XVID_VOP_MODEDECISION_RD;
-            x->me_flags  |=  XVID_ME_HALFPELREFINE8_RD
-                         |   XVID_ME_QUARTERPELREFINE8_RD
-                         |   XVID_ME_EXTSEARCH_RD
-                         |   XVID_ME_CHECKPREDICTION_RD;
-        case 1:
-            if( !(x->vop_flags & XVID_VOP_MODEDECISION_RD) )
-                x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
-            x->me_flags  |=  XVID_ME_HALFPELREFINE16_RD
-                         |   XVID_ME_QUARTERPELREFINE16_RD;
-        default:
-            break;
+     switch (avctx->mb_decision) {
+     case 2:
+         x->vop_flags |=  XVID_VOP_MODEDECISION_RD;
+         x->me_flags  |=  XVID_ME_HALFPELREFINE8_RD    |
+                          XVID_ME_QUARTERPELREFINE8_RD |
+                          XVID_ME_EXTSEARCH_RD         |
+                          XVID_ME_CHECKPREDICTION_RD;
+     case 1:
+         if (!(x->vop_flags & XVID_VOP_MODEDECISION_RD))
+             x->vop_flags |= XVID_VOP_FAST_MODEDECISION_RD;
+         x->me_flags |= XVID_ME_HALFPELREFINE16_RD |
+                        XVID_ME_QUARTERPELREFINE16_RD;
+     default:
+         break;
      }
  
 -    /* Bring in VOL flags from avconv command-line */
 +    /* Bring in VOL flags from ffmpeg command-line */
  #if FF_API_GMC
      if (avctx->flags & CODEC_FLAG_GMC)
          x->gmc = 1;
          x->old_twopassbuffer = av_malloc(BUFFER_SIZE);
          if (!x->twopassbuffer || !x->old_twopassbuffer) {
              av_log(avctx, AV_LOG_ERROR,
-                 "Xvid: Cannot allocate 2-pass log buffers\n");
+                    "Xvid: Cannot allocate 2-pass log buffers\n");
 -            return -1;
 +            goto fail;
          }
-         x->twopassbuffer[0] = x->old_twopassbuffer[0] = 0;
+         x->twopassbuffer[0]     =
+         x->old_twopassbuffer[0] = 0;
  
-         plugins[xvid_enc_create.num_plugins].func = xvid_ff_2pass;
+         plugins[xvid_enc_create.num_plugins].func  = xvid_ff_2pass;
          plugins[xvid_enc_create.num_plugins].param = &rc2pass1;
          xvid_enc_create.num_plugins++;
-     } else if( xvid_flags & CODEC_FLAG_PASS2 ) {
+     } else if (xvid_flags & CODEC_FLAG_PASS2) {
          rc2pass2.version = XVID_VERSION;
          rc2pass2.bitrate = avctx->bit_rate;
  
 -        fd = ff_tempfile("xvidff.", &x->twopassfile);
 +        fd = av_tempfile("xvidff.", &x->twopassfile, 0, avctx);
-         if( fd == -1 ) {
-             av_log(avctx, AV_LOG_ERROR,
-                 "Xvid: Cannot write 2-pass pipe\n");
+         if (fd == -1) {
+             av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write 2-pass pipe\n");
 -            return -1;
 +            goto fail;
          }
 +        x->twopassfd = fd;
  
          if (!avctx->stats_in) {
              av_log(avctx, AV_LOG_ERROR,
-                 "Xvid: No 2-pass information loaded for second pass\n");
+                    "Xvid: No 2-pass information loaded for second pass\n");
 -            return -1;
 +            goto fail;
          }
  
-         if( strlen(avctx->stats_in) >
-               write(fd, avctx->stats_in, strlen(avctx->stats_in)) ) {
-             av_log(avctx, AV_LOG_ERROR,
-                 "Xvid: Cannot write to 2-pass pipe\n");
+         if (strlen(avctx->stats_in) >
+             write(fd, avctx->stats_in, strlen(avctx->stats_in))) {
 -            close(fd);
+             av_log(avctx, AV_LOG_ERROR, "Xvid: Cannot write to 2-pass pipe\n");
 -            return -1;
 +            goto fail;
          }
  
-         rc2pass2.filename = x->twopassfile;
-         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_2pass2;
 -        close(fd);
+         rc2pass2.filename                          = x->twopassfile;
+         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_2pass2;
          plugins[xvid_enc_create.num_plugins].param = &rc2pass2;
          xvid_enc_create.num_plugins++;
-     } else if( !(xvid_flags & CODEC_FLAG_QSCALE) ) {
+     } else if (!(xvid_flags & CODEC_FLAG_QSCALE)) {
          /* Single Pass Bitrate Control! */
          single.version = XVID_VERSION;
          single.bitrate = avctx->bit_rate;
      if (avctx->lumi_masking != 0.0)
          x->lumi_aq = 1;
  
 -    if (x->lumi_aq && x->variance_aq) {
 -        x->variance_aq = 0;
 -        av_log(avctx, AV_LOG_WARNING,
 -               "variance_aq is ignored when lumi_aq is set.\n");
 -    }
 -
      /* Luminance Masking */
      if (x->lumi_aq) {
-         masking_l.method = 0;
+         masking_l.method                          = 0;
          plugins[xvid_enc_create.num_plugins].func = xvid_plugin_lumimasking;
  
          /* The old behavior is that when avctx->lumi_masking is specified,
          xvid_enc_create.num_plugins++;
      }
  
-     if( x->lumi_aq && x->variance_aq )
++    if (x->lumi_aq && x->variance_aq )
 +        av_log(avctx, AV_LOG_INFO,
 +               "Both lumi_aq and variance_aq are enabled. The resulting quality"
 +               "will be the worse one of the two effects made by the AQ.\n");
 +
      /* SSIM */
      if (x->ssim) {
-         plugins[xvid_enc_create.num_plugins].func = xvid_plugin_ssim;
-         ssim.b_printstat = x->ssim == 2;
-         ssim.acc         = x->ssim_acc;
-         ssim.cpu_flags   = xvid_gbl_init.cpu_flags;
-         ssim.b_visualize = 0;
+         plugins[xvid_enc_create.num_plugins].func  = xvid_plugin_ssim;
+         ssim.b_printstat                           = x->ssim == 2;
+         ssim.acc                                   = x->ssim_acc;
+         ssim.cpu_flags                             = xvid_gbl_init.cpu_flags;
+         ssim.b_visualize                           = 0;
          plugins[xvid_enc_create.num_plugins].param = &ssim;
          xvid_enc_create.num_plugins++;
      }
      }
  
      /* Bframes */
-     xvid_enc_create.max_bframes = avctx->max_b_frames;
+     xvid_enc_create.max_bframes   = avctx->max_b_frames;
      xvid_enc_create.bquant_offset = 100 * avctx->b_quant_offset;
-     xvid_enc_create.bquant_ratio = 100 * avctx->b_quant_factor;
-     if( avctx->max_b_frames > 0  && !x->quicktime_format ) xvid_enc_create.global |= XVID_GLOBAL_PACKED;
+     xvid_enc_create.bquant_ratio  = 100 * avctx->b_quant_factor;
+     if (avctx->max_b_frames > 0 && !x->quicktime_format)
+         xvid_enc_create.global |= XVID_GLOBAL_PACKED;
  
 +    av_assert0(xvid_enc_create.num_plugins + (!!x->ssim) + (!!x->variance_aq) + (!!x->lumi_aq) <= FF_ARRAY_ELEMS(plugins));
 +
      /* Create encoder context */
      xerr = xvid_encore(NULL, XVID_ENC_CREATE, &xvid_enc_create, NULL);
-     if( xerr ) {
+     if (xerr) {
          av_log(avctx, AV_LOG_ERROR, "Xvid: Could not create encoder reference\n");
 -        return -1;
 +        goto fail;
      }
  
-     x->encoder_handle = xvid_enc_create.handle;
+     x->encoder_handle  = xvid_enc_create.handle;
      avctx->coded_frame = av_frame_alloc();
      if (!avctx->coded_frame)
          return AVERROR(ENOMEM);
@@@ -688,9 -679,10 +693,10 @@@ static int xvid_encode_frame(AVCodecCon
      xvid_enc_frame.length    = pkt->size;
  
      /* Initialize input image fields */
-     if( avctx->pix_fmt != AV_PIX_FMT_YUV420P ) {
-         av_log(avctx, AV_LOG_ERROR, "Xvid: Color spaces other than 420p not supported\n");
+     if (avctx->pix_fmt != AV_PIX_FMT_YUV420P) {
+         av_log(avctx, AV_LOG_ERROR,
+                "Xvid: Color spaces other than 420P not supported\n");
 -        return -1;
 +        return AVERROR(EINVAL);
      }
  
      xvid_enc_frame.input.csp = XVID_CSP_PLANAR; /* YUV420P */
          picture->pict_type == AV_PICTURE_TYPE_I ? XVID_TYPE_IVOP :
          picture->pict_type == AV_PICTURE_TYPE_P ? XVID_TYPE_PVOP :
          picture->pict_type == AV_PICTURE_TYPE_B ? XVID_TYPE_BVOP :
-                                           XVID_TYPE_AUTO;
+                                                   XVID_TYPE_AUTO;
  
      /* Pixel aspect ratio setting */
 -    if (avctx->sample_aspect_ratio.num < 1 || avctx->sample_aspect_ratio.num > 255 ||
 -        avctx->sample_aspect_ratio.den < 1 || avctx->sample_aspect_ratio.den > 255) {
 -        av_log(avctx, AV_LOG_ERROR, "Invalid pixel aspect ratio %i/%i\n",
 +    if (avctx->sample_aspect_ratio.num < 0 || avctx->sample_aspect_ratio.num > 255 ||
 +        avctx->sample_aspect_ratio.den < 0 || avctx->sample_aspect_ratio.den > 255) {
 +        av_log(avctx, AV_LOG_WARNING,
 +               "Invalid pixel aspect ratio %i/%i, limit is 255/255 reducing\n",
                 avctx->sample_aspect_ratio.num, avctx->sample_aspect_ratio.den);
 -        return -1;
 +        av_reduce(&avctx->sample_aspect_ratio.num, &avctx->sample_aspect_ratio.den,
 +                   avctx->sample_aspect_ratio.num,  avctx->sample_aspect_ratio.den, 255);
      }
-     xvid_enc_frame.par = XVID_PAR_EXT;
+     xvid_enc_frame.par        = XVID_PAR_EXT;
      xvid_enc_frame.par_width  = avctx->sample_aspect_ratio.num;
      xvid_enc_frame.par_height = avctx->sample_aspect_ratio.den;
  
              av_free_packet(pkt);
          if (!xerr)
              return 0;
-         av_log(avctx, AV_LOG_ERROR, "Xvid: Encoding Error Occurred: %i\n", xerr);
+         av_log(avctx, AV_LOG_ERROR,
+                "Xvid: Encoding Error Occurred: %i\n", xerr);
 -        return -1;
 +        return AVERROR_EXTERNAL;
      }
  }
  
- static av_cold int xvid_encode_close(AVCodecContext *avctx) {
+ static av_cold int xvid_encode_close(AVCodecContext *avctx)
+ {
      struct xvid_context *x = avctx->priv_data;
  
 -    xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
 +    if(x->encoder_handle)
 +        xvid_encore(x->encoder_handle, XVID_ENC_DESTROY, NULL, NULL);
 +    x->encoder_handle = NULL;
  
      av_freep(&avctx->extradata);
      if (x->twopassbuffer) {
Simple merge
   */
  
  #include "config.h"
- #include <xvid.h>
- #include "libavutil/attributes.h"
- #include "libavutil/file.h"
- #include "avcodec.h"
- #include "libxvid.h"
- #include "mpegvideo.h"
 -#if !HAVE_MKSTEMP
 -#include <fcntl.h>
++#if HAVE_IO_H
++#include <io.h>
+ #endif
 +
 +#if HAVE_UNISTD_H
  #include <unistd.h>
- #if HAVE_IO_H
- #include <io.h>
- #endif
 +#endif
 +
+ #include <xvid.h>
  
- #undef NDEBUG
- #include <assert.h>
+ #include "libavutil/attributes.h"
 -#include "libavutil/internal.h"
++#include "libavutil/file.h"
+ #include "avcodec.h"
+ #include "libxvid.h"
+ #include "mpegvideo.h"
  
 -/* Wrapper to work around the lack of mkstemp() on mingw.
 - * Also, tries to create file in /tmp first, if possible.
 - * *prefix can be a character constant; *filename will be allocated internally.
 - * @return file descriptor of opened file (or -1 on error)
 - * and opened file name in **filename. */
 -int ff_tempfile(const char *prefix, char **filename)
 -{
 -    int fd = -1;
 -#if !HAVE_MKSTEMP
 -    *filename = tempnam(".", prefix);
 -#else
 -    size_t len = strlen(prefix) + 12; /* room for "/tmp/" and "XXXXXX\0" */
 -    *filename  = av_malloc(len);
 -#endif
 -    /* -----common section-----*/
 -    if (!(*filename)) {
 -        av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot allocate file name\n");
 -        return -1;
 -    }
 -#if !HAVE_MKSTEMP
 -    fd = avpriv_open(*filename, O_RDWR | O_BINARY | O_CREAT, 0444);
 -#else
 -    snprintf(*filename, len, "/tmp/%sXXXXXX", prefix);
 -    fd = mkstemp(*filename);
 -    if (fd < 0) {
 -        snprintf(*filename, len, "./%sXXXXXX", prefix);
 -        fd = mkstemp(*filename);
 -    }
 -#endif
 -    /* -----common section-----*/
 -    if (fd < 0) {
 -        av_log(NULL, AV_LOG_ERROR, "ff_tempfile: Cannot open temporary file %s\n", *filename);
 -        return -1;
 -    }
 -    return fd; /* success */
 -}
 -
  av_cold int ff_xvid_rate_control_init(MpegEncContext *s)
  {
      char *tmp_name;
@@@ -46,7 -79,7 +46,7 @@@
      xvid_plg_create_t xvid_plg_create = { 0 };
      xvid_plugin_2pass2_t xvid_2pass2  = { 0 };
  
-     fd=av_tempfile("xvidrc.", &tmp_name, 0, s->avctx);
 -    fd = ff_tempfile("xvidrc.", &tmp_name);
++    fd = av_tempfile("xvidrc.", &tmp_name, 0, s->avctx);
      if (fd == -1) {
          av_log(NULL, AV_LOG_ERROR, "Can't create temporary pass2 file.\n");
          return -1;
          char tmp[256];
          RateControlEntry *rce;
  
-         rce= &s->rc_context.entry[i];
+         rce = &s->rc_context.entry[i];
  
          snprintf(tmp, sizeof(tmp), "%c %d %d %d %d %d %d\n",
-             frame_types[rce->pict_type], (int)lrintf(rce->qscale / FF_QP2LAMBDA), rce->i_count, s->mb_num - rce->i_count - rce->skip_count,
-             rce->skip_count, (rce->i_tex_bits + rce->p_tex_bits + rce->misc_bits+7)/8, (rce->header_bits+rce->mv_bits+7)/8);
+                  frame_types[rce->pict_type],
+                  (int) lrintf(rce->qscale / FF_QP2LAMBDA),
+                  rce->i_count, s->mb_num - rce->i_count - rce->skip_count,
+                  rce->skip_count,
+                  (rce->i_tex_bits + rce->p_tex_bits + rce->misc_bits + 7) / 8,
+                  (rce->header_bits + rce->mv_bits + 7) / 8);
  
 -        write(fd, tmp, strlen(tmp));
 +        if (write(fd, tmp, strlen(tmp)) < 0) {
 +            av_log(NULL, AV_LOG_ERROR, "Error %s writing 2pass logfile\n", strerror(errno));
 +            av_free(tmp_name);
 +            close(fd);
 +            return AVERROR(errno);
 +        }
      }
  
      close(fd);
@@@ -136,69 -136,3 +136,70 @@@ void av_file_unmap(uint8_t *bufptr, siz
      av_free(bufptr);
  #endif
  }
- int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx) {
 +
-     int fd=-1;
++int av_tempfile(const char *prefix, char **filename, int log_offset, void *log_ctx)
++{
 +    FileLogContext file_log_ctx = { &file_log_ctx_class, log_offset, log_ctx };
-     *filename = av_malloc(len);
++    int fd = -1;
 +#if !HAVE_MKSTEMP
 +    void *ptr= tempnam(NULL, prefix);
 +    if(!ptr)
 +        ptr= tempnam(".", prefix);
 +    *filename = av_strdup(ptr);
 +#undef free
 +    free(ptr);
 +#else
 +    size_t len = strlen(prefix) + 12; /* room for "/tmp/" and "XXXXXX\0" */
++    *filename  = av_malloc(len);
 +#endif
 +    /* -----common section-----*/
 +    if (!*filename) {
 +        av_log(&file_log_ctx, AV_LOG_ERROR, "ff_tempfile: Cannot allocate file name\n");
 +        return AVERROR(ENOMEM);
 +    }
 +#if !HAVE_MKSTEMP
 +#   ifndef O_BINARY
 +#       define O_BINARY 0
 +#   endif
 +#   ifndef O_EXCL
 +#       define O_EXCL 0
 +#   endif
 +    fd = open(*filename, O_RDWR | O_BINARY | O_CREAT | O_EXCL, 0600);
 +#else
 +    snprintf(*filename, len, "/tmp/%sXXXXXX", prefix);
 +    fd = mkstemp(*filename);
 +#ifdef _WIN32
 +    if (fd < 0) {
 +        snprintf(*filename, len, "./%sXXXXXX", prefix);
 +        fd = mkstemp(*filename);
 +    }
 +#endif
 +#endif
 +    /* -----common section-----*/
 +    if (fd < 0) {
 +        int err = AVERROR(errno);
 +        av_log(&file_log_ctx, AV_LOG_ERROR, "ff_tempfile: Cannot open temporary file %s\n", *filename);
 +        av_freep(filename);
 +        return err;
 +    }
 +    return fd; /* success */
 +}
 +
 +#ifdef TEST
 +
 +#undef printf
 +
 +int main(void)
 +{
 +    uint8_t *buf;
 +    size_t size;
 +    if (av_file_map("file.c", &buf, &size, 0, NULL) < 0)
 +        return 1;
 +
 +    buf[0] = 's';
 +    printf("%s", buf);
 +    av_file_unmap(buf, size);
 +    return 0;
 +}
 +#endif
 +