Merge commit '1ea9fa15c3f9074f6199f68bdd6258c5a2bb89e0'
authorMichael Niedermayer <michaelni@gmx.at>
Wed, 19 Mar 2014 00:06:29 +0000 (01:06 +0100)
committerMichael Niedermayer <michaelni@gmx.at>
Wed, 19 Mar 2014 00:06:29 +0000 (01:06 +0100)
* commit '1ea9fa15c3f9074f6199f68bdd6258c5a2bb89e0':
  libopenjpeg: K&R formatting cosmetics

Conflicts:
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c

   */
  
  #define  OPJ_STATIC
 -#include <openjpeg.h>
  
  #include "libavutil/common.h"
- #include "libavutil/intreadwrite.h"
  #include "libavutil/imgutils.h"
- #include "libavutil/pixfmt.h"
+ #include "libavutil/intreadwrite.h"
  #include "libavutil/opt.h"
+ #include "libavutil/pixfmt.h"
  #include "avcodec.h"
  #include "internal.h"
  #include "thread.h"
  
  // pix_fmts with lower bpp have to be listed before
  // similar pix_fmts with higher bpp.
- #define RGB_PIXEL_FORMATS   AV_PIX_FMT_RGB24,AV_PIX_FMT_RGBA,AV_PIX_FMT_RGB48,AV_PIX_FMT_RGBA64
- #define GRAY_PIXEL_FORMATS  AV_PIX_FMT_GRAY8,AV_PIX_FMT_GRAY8A,AV_PIX_FMT_GRAY16
- #define YUV_PIXEL_FORMATS   AV_PIX_FMT_YUV410P,AV_PIX_FMT_YUV411P,AV_PIX_FMT_YUVA420P, \
-                             AV_PIX_FMT_YUV420P,AV_PIX_FMT_YUV422P,AV_PIX_FMT_YUVA422P, \
-                             AV_PIX_FMT_YUV440P,AV_PIX_FMT_YUV444P,AV_PIX_FMT_YUVA444P, \
-                             AV_PIX_FMT_YUV420P9,AV_PIX_FMT_YUV422P9,AV_PIX_FMT_YUV444P9, \
-                             AV_PIX_FMT_YUVA420P9,AV_PIX_FMT_YUVA422P9,AV_PIX_FMT_YUVA444P9, \
-                             AV_PIX_FMT_YUV420P10,AV_PIX_FMT_YUV422P10,AV_PIX_FMT_YUV444P10, \
-                             AV_PIX_FMT_YUVA420P10,AV_PIX_FMT_YUVA422P10,AV_PIX_FMT_YUVA444P10, \
-                             AV_PIX_FMT_YUV420P12,AV_PIX_FMT_YUV422P12,AV_PIX_FMT_YUV444P12, \
-                             AV_PIX_FMT_YUV420P14,AV_PIX_FMT_YUV422P14,AV_PIX_FMT_YUV444P14, \
-                             AV_PIX_FMT_YUV420P16,AV_PIX_FMT_YUV422P16,AV_PIX_FMT_YUV444P16, \
-                             AV_PIX_FMT_YUVA420P16,AV_PIX_FMT_YUVA422P16,AV_PIX_FMT_YUVA444P16
+ #define RGB_PIXEL_FORMATS  AV_PIX_FMT_RGB24, AV_PIX_FMT_RGBA,                 \
 -                           AV_PIX_FMT_RGB48
++                           AV_PIX_FMT_RGB48, AV_PIX_FMT_RGBA64
 -#define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_Y400A,                \
++#define GRAY_PIXEL_FORMATS AV_PIX_FMT_GRAY8, AV_PIX_FMT_GRAY8A,               \
+                            AV_PIX_FMT_GRAY16
 -#define YUV_PIXEL_FORMATS  AV_PIX_FMT_YUV410P,   AV_PIX_FMT_YUV411P,          \
 -                           AV_PIX_FMT_YUVA420P,                               \
 -                           AV_PIX_FMT_YUV420P,   AV_PIX_FMT_YUV422P,          \
 -                           AV_PIX_FMT_YUV440P,   AV_PIX_FMT_YUV444P,          \
 -                           AV_PIX_FMT_YUV420P9,  AV_PIX_FMT_YUV422P9,         \
 -                           AV_PIX_FMT_YUV444P9,                               \
 -                           AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10,        \
 -                           AV_PIX_FMT_YUV444P10,                              \
 -                           AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16,        \
 -                           AV_PIX_FMT_YUV444P16
++#define YUV_PIXEL_FORMATS  AV_PIX_FMT_YUV410P, AV_PIX_FMT_YUV411P, AV_PIX_FMT_YUVA420P, \
++                           AV_PIX_FMT_YUV420P, AV_PIX_FMT_YUV422P, AV_PIX_FMT_YUVA422P, \
++                           AV_PIX_FMT_YUV440P, AV_PIX_FMT_YUV444P, AV_PIX_FMT_YUVA444P, \
++                           AV_PIX_FMT_YUV420P9, AV_PIX_FMT_YUV422P9, AV_PIX_FMT_YUV444P9, \
++                           AV_PIX_FMT_YUVA420P9, AV_PIX_FMT_YUVA422P9, AV_PIX_FMT_YUVA444P9, \
++                           AV_PIX_FMT_YUV420P10, AV_PIX_FMT_YUV422P10, AV_PIX_FMT_YUV444P10, \
++                           AV_PIX_FMT_YUVA420P10, AV_PIX_FMT_YUVA422P10, AV_PIX_FMT_YUVA444P10, \
++                           AV_PIX_FMT_YUV420P12, AV_PIX_FMT_YUV422P12, AV_PIX_FMT_YUV444P12, \
++                           AV_PIX_FMT_YUV420P14, AV_PIX_FMT_YUV422P14, AV_PIX_FMT_YUV444P14, \
++                           AV_PIX_FMT_YUV420P16, AV_PIX_FMT_YUV422P16, AV_PIX_FMT_YUV444P16, \
++                           AV_PIX_FMT_YUVA420P16, AV_PIX_FMT_YUVA422P16, AV_PIX_FMT_YUVA444P16
  
  #define XYZ_PIXEL_FORMATS  AV_PIX_FMT_XYZ12
  
- static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]  = {RGB_PIXEL_FORMATS};
- static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = {GRAY_PIXEL_FORMATS};
- static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]  = {YUV_PIXEL_FORMATS};
- static const enum AVPixelFormat libopenjpeg_all_pix_fmts[]  = {RGB_PIXEL_FORMATS,
-                                                                GRAY_PIXEL_FORMATS,
-                                                                YUV_PIXEL_FORMATS,
-                                                                XYZ_PIXEL_FORMATS};
 -static const enum AVPixelFormat rgb_pix_fmts[] = {
++static const enum AVPixelFormat libopenjpeg_rgb_pix_fmts[]  = {
+     RGB_PIXEL_FORMATS
+ };
 -static const enum AVPixelFormat gray_pix_fmts[] = {
++static const enum AVPixelFormat libopenjpeg_gray_pix_fmts[] = {
+     GRAY_PIXEL_FORMATS
+ };
 -static const enum AVPixelFormat yuv_pix_fmts[] = {
++static const enum AVPixelFormat libopenjpeg_yuv_pix_fmts[]  = {
+     YUV_PIXEL_FORMATS
+ };
 -static const enum AVPixelFormat any_pix_fmts[] = {
++static const enum AVPixelFormat libopenjpeg_all_pix_fmts[]  = {
+     RGB_PIXEL_FORMATS, GRAY_PIXEL_FORMATS, YUV_PIXEL_FORMATS, XYZ_PIXEL_FORMATS
+ };
  
  typedef struct {
      AVClass *class;
@@@ -86,18 -92,26 +96,26 @@@ static inline int libopenjpeg_matches_p
      }
  
      switch (desc->nb_components) {
-     case 4: match = match && desc->comp[3].depth_minus1 + 1 >= image->comps[3].prec &&
-                              1 == image->comps[3].dx &&
-                              1 == image->comps[3].dy;
-     case 3: match = match && desc->comp[2].depth_minus1 + 1 >= image->comps[2].prec &&
-                              1 << desc->log2_chroma_w == image->comps[2].dx &&
-                              1 << desc->log2_chroma_h == image->comps[2].dy;
-     case 2: match = match && desc->comp[1].depth_minus1 + 1 >= image->comps[1].prec &&
-                              1 << desc->log2_chroma_w == image->comps[1].dx &&
-                              1 << desc->log2_chroma_h == image->comps[1].dy;
-     case 1: match = match && desc->comp[0].depth_minus1 + 1 >= image->comps[0].prec &&
-                              1 == image->comps[0].dx &&
-                              1 == image->comps[0].dy;
+     case 4:
+         match = match &&
 -                desc->comp[3].depth_minus1 + 1 >= img->comps[3].prec &&
 -                1 == img->comps[3].dx &&
 -                1 == img->comps[3].dy;
++                desc->comp[3].depth_minus1 + 1 >= image->comps[3].prec &&
++                1 == image->comps[3].dx &&
++                1 == image->comps[3].dy;
+     case 3:
+         match = match &&
 -                desc->comp[2].depth_minus1 + 1 >= img->comps[2].prec &&
 -                1 << desc->log2_chroma_w == img->comps[2].dx &&
 -                1 << desc->log2_chroma_h == img->comps[2].dy;
++                desc->comp[2].depth_minus1 + 1 >= image->comps[2].prec &&
++                1 << desc->log2_chroma_w == image->comps[2].dx &&
++                1 << desc->log2_chroma_h == image->comps[2].dy;
+     case 2:
+         match = match &&
 -                desc->comp[1].depth_minus1 + 1 >= img->comps[1].prec &&
 -                1 << desc->log2_chroma_w == img->comps[1].dx &&
 -                1 << desc->log2_chroma_h == img->comps[1].dy;
++                desc->comp[1].depth_minus1 + 1 >= image->comps[1].prec &&
++                1 << desc->log2_chroma_w == image->comps[1].dx &&
++                1 << desc->log2_chroma_h == image->comps[1].dy;
+     case 1:
+         match = match &&
 -                desc->comp[0].depth_minus1 + 1 >= img->comps[0].prec &&
 -                1 == img->comps[0].dx &&
 -                1 == img->comps[0].dy;
++                desc->comp[0].depth_minus1 + 1 >= image->comps[0].prec &&
++                1 == image->comps[0].dx &&
++                1 == image->comps[0].dy;
      default:
          break;
      }
@@@ -112,20 -127,20 +130,20 @@@ static inline enum AVPixelFormat libope
  
      switch (image->color_space) {
      case CLRSPC_SRGB:
-         possible_fmts = libopenjpeg_rgb_pix_fmts;
 -        possible_fmts    = rgb_pix_fmts;
 -        possible_fmts_nb = FF_ARRAY_ELEMS(rgb_pix_fmts);
++        possible_fmts    = libopenjpeg_rgb_pix_fmts;
 +        possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_rgb_pix_fmts);
          break;
      case CLRSPC_GRAY:
-         possible_fmts = libopenjpeg_gray_pix_fmts;
 -        possible_fmts    = gray_pix_fmts;
 -        possible_fmts_nb = FF_ARRAY_ELEMS(gray_pix_fmts);
++        possible_fmts    = libopenjpeg_gray_pix_fmts;
 +        possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_gray_pix_fmts);
          break;
      case CLRSPC_SYCC:
-         possible_fmts = libopenjpeg_yuv_pix_fmts;
 -        possible_fmts    = yuv_pix_fmts;
 -        possible_fmts_nb = FF_ARRAY_ELEMS(yuv_pix_fmts);
++        possible_fmts    = libopenjpeg_yuv_pix_fmts;
 +        possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_yuv_pix_fmts);
          break;
      default:
-         possible_fmts = libopenjpeg_all_pix_fmts;
 -        possible_fmts    = any_pix_fmts;
 -        possible_fmts_nb = FF_ARRAY_ELEMS(any_pix_fmts);
++        possible_fmts    = libopenjpeg_all_pix_fmts;
 +        possible_fmts_nb = FF_ARRAY_ELEMS(libopenjpeg_all_pix_fmts);
          break;
      }
  
@@@ -153,18 -167,17 +170,15 @@@ static inline int libopenjpeg_ispacked(
      return 1;
  }
  
 -static void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image)
 -{
 +static inline void libopenjpeg_copy_to_packed8(AVFrame *picture, opj_image_t *image) {
      uint8_t *img_ptr;
      int index, x, y, c;
 -
      for (y = 0; y < picture->height; y++) {
-         index = y*picture->width;
-         img_ptr = picture->data[0] + y*picture->linesize[0];
-         for (x = 0; x < picture->width; x++, index++) {
-             for (c = 0; c < image->numcomps; c++) {
+         index   = y * picture->width;
+         img_ptr = picture->data[0] + y * picture->linesize[0];
+         for (x = 0; x < picture->width; x++, index++)
+             for (c = 0; c < image->numcomps; c++)
 -                *img_ptr++ = image->comps[c].data[index];
 +                *img_ptr++ = 0x80 * image->comps[c].sgnd + image->comps[c].data[index];
-             }
-         }
      }
  }
  
@@@ -172,18 -186,16 +186,16 @@@ static inline void libopenjpeg_copy_to_
      uint16_t *img_ptr;
      int index, x, y, c;
      int adjust[4];
 -
      for (x = 0; x < image->numcomps; x++)
 -        adjust[x] = FFMAX(FFMIN(16 - image->comps[x].prec, 8), 0);
 +        adjust[x] = FFMAX(FFMIN(av_pix_fmt_desc_get(picture->format)->comp[x].depth_minus1 + 1 - image->comps[x].prec, 8), 0);
  
      for (y = 0; y < picture->height; y++) {
-         index = y*picture->width;
-         img_ptr = (uint16_t*) (picture->data[0] + y*picture->linesize[0]);
-         for (x = 0; x < picture->width; x++, index++) {
-             for (c = 0; c < image->numcomps; c++) {
+         index   = y * picture->width;
+         img_ptr = (uint16_t *) (picture->data[0] + y * picture->linesize[0]);
+         for (x = 0; x < picture->width; x++, index++)
+             for (c = 0; c < image->numcomps; c++)
 -                *img_ptr++ = image->comps[c].data[index] << adjust[c];
 +                *img_ptr++ = (1 << image->comps[c].prec - 1) * image->comps[c].sgnd +
 +                             (unsigned)image->comps[c].data[index] << adjust[c];
-             }
-         }
      }
  }
  
@@@ -216,10 -227,9 +228,10 @@@ static inline void libopenjpeg_copyto16
      for (index = 0; index < image->numcomps; index++) {
          comp_data = image->comps[index].data;
          for (y = 0; y < image->comps[index].h; y++) {
-             img_ptr = (uint16_t*) (picture->data[index] + y * picture->linesize[index]);
 -            img_ptr = (uint16_t *)(p->data[index] + y * p->linesize[index]);
++            img_ptr = (uint16_t *)(picture->data[index] + y * picture->linesize[index]);
              for (x = 0; x < image->comps[index].w; x++) {
 -                *img_ptr = *comp_data;
 +                *img_ptr = (1 << image->comps[index].prec - 1) * image->comps[index].sgnd +
 +                           (unsigned)*comp_data << adjust[index];
                  img_ptr++;
                  comp_data++;
              }
@@@ -272,8 -282,10 +284,8 @@@ static int libopenjpeg_decode_frame(AVC
          av_log(avctx, AV_LOG_ERROR, "Error initializing decoder.\n");
          return AVERROR_UNKNOWN;
      }
-     opj_set_event_mgr((opj_common_ptr)dec, NULL, NULL);
+     opj_set_event_mgr((opj_common_ptr) dec, NULL, NULL);
 -
      ctx->dec_params.cp_limit_decoding = LIMIT_TO_MAIN_HEADER;
 -    ctx->dec_params.cp_reduce         = ctx->lowres;
      ctx->dec_params.cp_layer          = ctx->lowqual;
      // Tie decoder with decoding parameters
      opj_setup_decoder(dec, &ctx->dec_params);
          if (image->comps[i].prec > avctx->bits_per_raw_sample)
              avctx->bits_per_raw_sample = image->comps[i].prec;
  
 -    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0) {
 -        av_log(avctx, AV_LOG_ERROR, "ff_thread_get_buffer() failed\n");
 +    if ((ret = ff_thread_get_buffer(avctx, &frame, 0)) < 0)
          goto done;
 -    }
  
      ctx->dec_params.cp_limit_decoding = NO_LIMITATION;
 +    ctx->dec_params.cp_reduce = avctx->lowres;
      // Tie decoder with decoding parameters.
      opj_setup_decoder(dec, &ctx->dec_params);
-     stream = opj_cio_open((opj_common_ptr)dec, buf, buf_size);
+     stream = opj_cio_open((opj_common_ptr) dec, buf, buf_size);
      if (!stream) {
          av_log(avctx, AV_LOG_ERROR,
                 "Codestream could not be opened for reading.\n");
@@@ -394,7 -414,10 +406,8 @@@ done
  #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
  
  static const AVOption options[] = {
-     { "lowqual", "Limit the number of layers used for decoding",    OFFSET(lowqual), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
+     { "lowqual", "Limit the number of layers used for decoding",
+         OFFSET(lowqual), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
 -    { "lowres",  "Lower the decoding resolution by a power of two",
 -        OFFSET(lowres),  AV_OPT_TYPE_INT, { .i64 = 0 }, 0, INT_MAX, VD },
      { NULL },
  };
  
@@@ -406,14 -429,13 +419,14 @@@ static const AVClass openjpeg_class = 
  };
  
  AVCodec ff_libopenjpeg_decoder = {
-     .name             = "libopenjpeg",
-     .long_name        = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
-     .type             = AVMEDIA_TYPE_VIDEO,
-     .id               = AV_CODEC_ID_JPEG2000,
-     .priv_data_size   = sizeof(LibOpenJPEGContext),
-     .init             = libopenjpeg_decode_init,
-     .decode           = libopenjpeg_decode_frame,
-     .capabilities     = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
-     .max_lowres       = 31,
-     .priv_class       = &openjpeg_class,
+     .name           = "libopenjpeg",
+     .long_name      = NULL_IF_CONFIG_SMALL("OpenJPEG JPEG 2000"),
+     .type           = AVMEDIA_TYPE_VIDEO,
+     .id             = AV_CODEC_ID_JPEG2000,
+     .priv_data_size = sizeof(LibOpenJPEGContext),
+     .init           = libopenjpeg_decode_init,
+     .decode         = libopenjpeg_decode_frame,
+     .capabilities   = CODEC_CAP_DR1 | CODEC_CAP_FRAME_THREADS,
 -    .priv_class     = &class,
++    .max_lowres     = 31,
++    .priv_class     = &openjpeg_class,
  };
@@@ -233,26 -180,11 +233,26 @@@ static av_cold int libopenjpeg_encode_i
          err = AVERROR(EINVAL);
          goto fail;
      }
 +    opj_setup_encoder(ctx->compress, &ctx->enc_params, ctx->image);
  
-     ctx->stream = opj_cio_open((opj_common_ptr)ctx->compress, NULL, 0);
++    ctx->stream = opj_cio_open((opj_common_ptr) ctx->compress, NULL, 0);
 +    if (!ctx->stream) {
 +        av_log(avctx, AV_LOG_ERROR, "Error creating the cio stream\n");
 +        err = AVERROR(ENOMEM);
 +        goto fail;
 +    }
 +
 +    avctx->coded_frame = av_frame_alloc();
 +    if (!avctx->coded_frame) {
 +        av_log(avctx, AV_LOG_ERROR, "Error allocating coded frame\n");
 +        goto fail;
 +    }
 +
 +    memset(&ctx->event_mgr, 0, sizeof(opj_event_mgr_t));
      ctx->event_mgr.info_handler    = info_callback;
 -    ctx->event_mgr.error_handler   = error_callback;
 +    ctx->event_mgr.error_handler = error_callback;
      ctx->event_mgr.warning_handler = warning_callback;
-     opj_set_event_mgr((opj_common_ptr)ctx->compress, &ctx->event_mgr, avctx);
+     opj_set_event_mgr((opj_common_ptr) ctx->compress, &ctx->event_mgr, avctx);
  
      return 0;
  
@@@ -267,220 -194,109 +267,219 @@@ fail
      return err;
  }
  
 -static void libopenjpeg_copy_packed8(AVCodecContext *avctx,
 -                                     const AVFrame *frame, opj_image_t *image)
 +static int libopenjpeg_copy_packed8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  {
      int compno;
 -    int x, y;
 -    int image_index, frame_index;
 +    int x;
 +    int y;
 +    int *image_line;
 +    int frame_index;
      const int numcomps = image->numcomps;
  
 -    for (compno = 0; compno < numcomps; ++compno)
 +    for (compno = 0; compno < numcomps; ++compno) {
 +        if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 +            av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 +            return 0;
 +        }
 +    }
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
          for (y = 0; y < avctx->height; ++y) {
 -            image_index = y * avctx->width;
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
              frame_index = y * frame->linesize[0] + compno;
              for (x = 0; x < avctx->width; ++x) {
 -                image->comps[compno].data[image_index++] =
 -                    frame->data[0][frame_index];
 +                image_line[x] = frame->data[0][frame_index];
                  frame_index += numcomps;
              }
 +            for (; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - 1];
 +            }
 +        }
 +        for (; y < image->comps[compno].h; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            for (x = 0; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - image->comps[compno].w];
 +            }
          }
 +    }
 +
 +    return 1;
  }
  
 -static void libopenjpeg_copy_packed16(AVCodecContext *avctx,
 -                                      const AVFrame *frame, opj_image_t *image)
 +// for XYZ 12 bit
 +static int libopenjpeg_copy_packed12(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  {
      int compno;
-     int x;
-     int y;
+     int x, y;
 -    int image_index, frame_index;
 +    int *image_line;
 +    int frame_index;
-     const int numcomps = image->numcomps;
-     uint16_t *frame_ptr = (uint16_t*)frame->data[0];
+     const int numcomps  = image->numcomps;
+     uint16_t *frame_ptr = (uint16_t *)frame->data[0];
  
 -    for (compno = 0; compno < numcomps; ++compno)
 +    for (compno = 0; compno < numcomps; ++compno) {
 +        if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 +            av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 +            return 0;
 +        }
 +    }
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
 +        for (y = 0; y < avctx->height; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            frame_index = y * (frame->linesize[0] / 2) + compno;
 +            for (x = 0; x < avctx->width; ++x) {
 +                image_line[x] = frame_ptr[frame_index] >> 4;
 +                frame_index += numcomps;
 +            }
 +            for (; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - 1];
 +            }
 +        }
 +        for (; y < image->comps[compno].h; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            for (x = 0; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - image->comps[compno].w];
 +            }
 +        }
 +    }
 +
 +    return 1;
 +}
 +
 +static int libopenjpeg_copy_packed16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
 +{
 +    int compno;
 +    int x;
 +    int y;
 +    int *image_line;
 +    int frame_index;
 +    const int numcomps = image->numcomps;
 +    uint16_t *frame_ptr = (uint16_t*)frame->data[0];
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
 +        if (image->comps[compno].w > frame->linesize[0] / numcomps) {
 +            av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 +            return 0;
 +        }
 +    }
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
          for (y = 0; y < avctx->height; ++y) {
 -            image_index = y * avctx->width;
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
              frame_index = y * (frame->linesize[0] / 2) + compno;
              for (x = 0; x < avctx->width; ++x) {
 -                image->comps[compno].data[image_index++] =
 -                    frame_ptr[frame_index];
 +                image_line[x] = frame_ptr[frame_index];
                  frame_index += numcomps;
              }
 +            for (; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - 1];
 +            }
 +        }
 +        for (; y < image->comps[compno].h; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            for (x = 0; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - image->comps[compno].w];
 +            }
          }
 +    }
 +
 +    return 1;
  }
  
 -static void libopenjpeg_copy_unpacked8(AVCodecContext *avctx,
 -                                       const AVFrame *frame, opj_image_t *image)
 +static int libopenjpeg_copy_unpacked8(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  {
      int compno;
 -    int x, y;
 -    int width, height;
 -    int image_index, frame_index;
 +    int x;
 +    int y;
 +    int width;
 +    int height;
 +    int *image_line;
 +    int frame_index;
      const int numcomps = image->numcomps;
  
      for (compno = 0; compno < numcomps; ++compno) {
-         width = avctx->width / image->comps[compno].dx;
 +        if (image->comps[compno].w > frame->linesize[compno]) {
 +            av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 +            return 0;
 +        }
 +    }
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
+         width  = avctx->width / image->comps[compno].dx;
          height = avctx->height / image->comps[compno].dy;
          for (y = 0; y < height; ++y) {
 -            image_index = y * width;
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
              frame_index = y * frame->linesize[compno];
              for (x = 0; x < width; ++x)
 -                image->comps[compno].data[image_index++] =
 -                    frame->data[compno][frame_index++];
 +                image_line[x] = frame->data[compno][frame_index++];
 +            for (; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - 1];
 +            }
 +        }
 +        for (; y < image->comps[compno].h; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            for (x = 0; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - image->comps[compno].w];
 +            }
          }
      }
 +
 +    return 1;
  }
  
 -static void libopenjpeg_copy_unpacked16(AVCodecContext *avctx,
 -                                        const AVFrame *frame,
 -                                        opj_image_t *image)
 +static int libopenjpeg_copy_unpacked16(AVCodecContext *avctx, const AVFrame *frame, opj_image_t *image)
  {
      int compno;
 -    int x, y;
 -    int width, height;
 -    int image_index, frame_index;
 +    int x;
 +    int y;
 +    int width;
 +    int height;
 +    int *image_line;
 +    int frame_index;
      const int numcomps = image->numcomps;
      uint16_t *frame_ptr;
  
      for (compno = 0; compno < numcomps; ++compno) {
-         width = avctx->width / image->comps[compno].dx;
-         height = avctx->height / image->comps[compno].dy;
-         frame_ptr = (uint16_t*)frame->data[compno];
 +        if (image->comps[compno].w > frame->linesize[compno]) {
 +            av_log(avctx, AV_LOG_ERROR, "Error: frame's linesize is too small for the image\n");
 +            return 0;
 +        }
 +    }
 +
 +    for (compno = 0; compno < numcomps; ++compno) {
+         width     = avctx->width / image->comps[compno].dx;
+         height    = avctx->height / image->comps[compno].dy;
+         frame_ptr = (uint16_t *)frame->data[compno];
          for (y = 0; y < height; ++y) {
 -            image_index = y * width;
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
              frame_index = y * (frame->linesize[compno] / 2);
              for (x = 0; x < width; ++x)
 -                image->comps[compno].data[image_index++] =
 -                    frame_ptr[frame_index++];
 +                image_line[x] = frame_ptr[frame_index++];
 +            for (; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - 1];
 +            }
 +        }
 +        for (; y < image->comps[compno].h; ++y) {
 +            image_line = image->comps[compno].data + y * image->comps[compno].w;
 +            for (x = 0; x < image->comps[compno].w; ++x) {
 +                image_line[x] = image_line[x - image->comps[compno].w];
 +            }
          }
      }
 +
 +    return 1;
  }
  
  static int libopenjpeg_encode_frame(AVCodecContext *avctx, AVPacket *pkt,
                                      const AVFrame *frame, int *got_packet)
  {
      LibOpenJPEGContext *ctx = avctx->priv_data;
-     opj_cinfo_t *compress = ctx->compress;
-     opj_image_t *image    = ctx->image;
-     opj_cio_t *stream     = ctx->stream;
+     opj_cinfo_t *compress   = ctx->compress;
+     opj_image_t *image      = ctx->image;
 -    opj_cio_t *stream;
++    opj_cio_t *stream       = ctx->stream;
 +    int cpyresult = 0;
      int ret, len;
 -
 -    // x0, y0 is the top left corner of the image
 -    // x1, y1 is the width, height of the reference grid
 -    image->x0 = 0;
 -    image->y0 = 0;
 -    image->x1 = (avctx->width - 1) * ctx->enc_params.subsampling_dx + 1;
 -    image->y1 = (avctx->height - 1) * ctx->enc_params.subsampling_dy + 1;
 +    AVFrame *gbrframe;
  
      switch (avctx->pix_fmt) {
      case AV_PIX_FMT_RGB24: