Merge commit '2268db2cd052674fde55c7d48b7a5098ce89b4ba'
authorHendrik Leppkes <h.leppkes@gmail.com>
Tue, 8 Sep 2015 13:43:03 +0000 (15:43 +0200)
committerHendrik Leppkes <h.leppkes@gmail.com>
Tue, 8 Sep 2015 14:35:28 +0000 (16:35 +0200)
* commit '2268db2cd052674fde55c7d48b7a5098ce89b4ba':
  lavu: Drop the {minus,plus}1 suffix from AVComponentDescriptor fields

Merged-by: Hendrik Leppkes <h.leppkes@gmail.com>
18 files changed:
1  2 
doc/APIchanges
libavcodec/hevc.c
libavcodec/hevc_refs.c
libavcodec/libopenjpegdec.c
libavcodec/libopenjpegenc.c
libavcodec/libx265.c
libavcodec/pnmenc.c
libavfilter/vf_hqdn3d.c
libavfilter/vf_yadif.c
libavutil/imgutils.c
libavutil/pixdesc.c
libavutil/pixdesc.h
libavutil/version.h
libswscale/output.c
libswscale/swscale.c
libswscale/swscale_internal.h
libswscale/swscale_unscaled.c
libswscale/utils.c

diff --cc doc/APIchanges
@@@ -19,108 -17,56 +19,110 @@@ API changes, most recent first
    xxxxxxx - Change type of AVPixFmtDescriptor.flags from uint8_t to uint64_t.
    xxxxxxx - Change type of AVComponentDescriptor fields from uint16_t to int
              and drop bit packing.
+   xxxxxxx - Add step, offset, and depth to AVComponentDescriptor to replace
+             the deprecated step_minus1, offset_plus1, and depth_minus1.
  
 -2015-xx-xx - lavu 54.17.0
 -  xxxxxxx -  Add av_blowfish_alloc().
 -  xxxxxxx -  Add av_rc4_alloc().
 -  xxxxxxx -  Add av_xtea_alloc().
 -  xxxxxxx -  Add av_des_alloc().
 -
 -2015-07-29 - 7e38340 - lavu 54.16.0 - hmac.h
 -  Add AV_HMAC_SHA224 and AV_HMAC_SHA256.
 -
 -2015-xx-xx - lavc 56.35.0 - avcodec.h
 -  xxxxxxxxx - Rename CODEC_FLAG* defines to AV_CODEC_FLAG*.
 -  xxxxxxxxx - Rename CODEC_CAP_* defines to AV_CODEC_CAP_*.
 -  xxxxxxxxx - Rename FF_INPUT_BUFFER_PADDING_SIZE and FF_MIN_BUFFER_SIZE
 +-------- 8< --------- FFmpeg 2.8 was cut here -------- 8< ---------
 +
 +2015-08-27 - 1dd854e1 - lavc 56.58.100 - vaapi.h
 +  Deprecate old VA-API context (vaapi_context) fields that were only
 +  set and used by libavcodec. They are all managed internally now.
 +
 +2015-08-19 - 9f8e57ef - lavu 54.31.100 - pixfmt.h
 +  Add a unique pixel format for VA-API (AV_PIX_FMT_VAAPI) that
 +  indicates the nature of the underlying storage: a VA surface. This
 +  yields the same value as AV_PIX_FMT_VAAPI_VLD.
 +  Deprecate old VA-API related pixel formats: AV_PIX_FMT_VAAPI_MOCO,
 +  AV_PIX_FMT_VAAPI_IDCT, AV_PIX_FMT_VAAPI_VLD.
 +
 +2015-08-02 - lavu 54.30.100 / 54.17.0
 +  9ed59f1 / 7a7df34c -  Add av_blowfish_alloc().
 +  a130ec9 / ae365453 -  Add av_rc4_alloc().
 +  9ca1997 / 5d8bea3b -  Add av_xtea_alloc().
 +  3cf08e9 / d9e8b47e -  Add av_des_alloc().
 +
 +2015-07-27 - lavc 56.56.100 / 56.35.0 - avcodec.h
 +  94d68a4 / 7c6eb0a1 - Rename CODEC_FLAG* defines to AV_CODEC_FLAG*.
 +  444e987 / def97856 - Rename CODEC_CAP_* defines to AV_CODEC_CAP_*.
 +  29d147c / 059a9348 - Rename FF_INPUT_BUFFER_PADDING_SIZE and FF_MIN_BUFFER_SIZE
                to AV_INPUT_BUFFER_PADDING_SIZE and AV_INPUT_BUFFER_MIN_SIZE.
  
 -2015-xx-xx - xxxxxxx - lavc 56.33.0 - avcodec.h
 -  Add AV_PKT_DATA_QUALITY_FACTOR to export the quality value of an AVPacket.
 +2015-07-22 - c40ecff - lavc 56.51.100 - avcodec.h
 +  Add AV_PKT_DATA_QUALITY_STATS to export the quality value, PSNR, and pict_type
 +  of an AVPacket.
  
 -2015-xx-xx - xxxxxxx - lavu 56.15.0
 +2015-07-16 - 8dad213 - lavc 56.49.100
 +  Add av_codec_get_codec_properties(), FF_CODEC_PROPERTY_LOSSLESS
 +  and FF_CODEC_PROPERTY_CLOSED_CAPTIONS
 +
 +2015-07-03 - d563e13 / 83212943 - lavu 54.28.100 / 56.15.0
    Add av_version_info().
  
 -2015-xx-xx - xxxxxxx - lavfi 5.1.0 - version.h
 -             xxxxxxx - lavd 55.2.0 - version.h
 -  Add library identification symbols, LIBAVFILTER_IDENT and LIBAVDEVICE_IDENT.
 +-------- 8< --------- FFmpeg 2.7 was cut here -------- 8< ---------
  
 -2015-xx-xx - xxxxxxx - lavf 56.20.0 - avio.h
 -  Add avio_put_str16be.
 +2015-06-04 - cc17b43 - lswr  1.2.100
 +  Add swr_get_out_samples()
  
 -2015-xx-xx - xxxxxxx - lavu 54.14.0 - cpu.h
 +2015-05-27 - c312bfa - lavu 54.26.100 - cpu.h
    Add AV_CPU_FLAG_AVXSLOW.
  
 -2015-xx-xx - xxxxxxx - lavc 56.23.0
 +2015-05-26 - 1fb9b2a - lavu 54.25.100 - rational.h
 +  Add av_q2intfloat().
 +
 +2015-05-13 - cc48409 / e7c5e17 - lavc 56.39.100 / 56.23.0
    Add av_vda_default_init2.
  
 -2015-xx-xx - xxxxxxx - lavu 54.12.0
 +2015-05-11 - 541d75f - lavf 56.33.100 - avformat.h
 +  Add AVOpenCallback AVFormatContext.open_cb
 +
 +2015-05-07 - a7dd933 - 56.38.100 - avcodec.h
 +  Add av_packet_side_data_name().
 +
 +2015-05-07 - 01e59d4 - 56.37.102 - avcodec.h
 +  Add FF_PROFILE_VP9_2 and FF_PROFILE_VP9_3.
 +
 +2015-05-04 - 079b7f6 - 56.37.100 - avcodec.h
 +  Add FF_PROFILE_VP9_0 and FF_PROFILE_VP9_1.
 +
 +2015-04-22 - 748d481 - lavf 56.31.100 - avformat.h
 +  Add AVFMT_FLAG_FAST_SEEK flag. Some formats (initially mp3) use it to enable
 +  fast, but inaccurate seeking.
 +
 +2015-04-20 - 8e8219e / c253340 - lavu 54.23.100 / 54.12.0 - log.h
    Add AV_LOG_TRACE for extremely verbose debugging.
  
 -2015-xx-xx - xxxxxxx - lavu 54.11.0
 -  Add av_small_strptime().
 +2015-04-02 - 26e0e393 - lavf 56.29.100 - avio.h
 +  Add AVIODirEntryType.AVIO_ENTRY_SERVER.
 +  Add AVIODirEntryType.AVIO_ENTRY_SHARE.
 +  Add AVIODirEntryType.AVIO_ENTRY_WORKGROUP.
  
 -2015-xx-xx - xxxxxxx - lavc 56.22.0
 -  Add FF_PROFILE_DTS_EXPRESS.
 +2015-03-31 - 3188696 - lavu 54.22.100 - avstring.h
 +  Add av_append_path_component()
 +
 +2015-03-27 - 184084c - lavf 56.27.100 - avio.h url.h
 +  New directory listing API.
 +
 +  Add AVIODirEntryType enum.
 +  Add AVIODirEntry, AVIODirContext structures.
 +  Add avio_open_dir(), avio_read_dir(), avio_close_dir(), avio_free_directory_entry().
 +  Add ff_alloc_dir_entry().
 +  Extend URLProtocol with url_open_dir(), url_read_dir(), url_close_dir().
  
 -2015-xx-xx - xxxxxxx - lavu 54.10.0
 +2015-03-29 - 268ff17 / c484561 - lavu 54.21.100 / 54.10.0 - pixfmt.h
    Add AV_PIX_FMT_MMAL for MMAL hardware acceleration.
  
 -2015-xx-xx - xxxxxxx - lavc 56.13
 +2015-03-19 - 11fe56c - 56.29.100 / lavc 56.22.0
 +  Add FF_PROFILE_DTS_EXPRESS.
 +
 +-------- 8< --------- FFmpeg 2.6 was cut here -------- 8< ---------
 +
 +2015-03-04 - cca4476 - lavf 56.25.100
 +  Add avformat_flush()
 +
 +2015-03-03 - 81a9126 - lavf 56.24.100
 +  Add avio_put_str16be()
 +
 +2015-02-19 - 560eb71 / 31d2039 - lavc 56.23.100 / 56.13.0
    Add width, height, coded_width, coded_height and format to
    AVCodecParserContext.
  
Simple merge
@@@ -203,16 -192,16 +203,16 @@@ int ff_hevc_output_frame(HEVCContext *s
  
          if (nb_output) {
              HEVCFrame *frame = &s->DPB[min_idx];
 -            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->frame->format);
 -            int pixel_shift;
 -
 -            if (!desc)
 -                return AVERROR_BUG;
 -
 -            pixel_shift = desc->comp[0].depth > 8;
 -
 -            ret = av_frame_ref(out, frame->frame);
 -            ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);
 +            AVFrame *dst = out;
 +            AVFrame *src = frame->frame;
 +            const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(src->format);
-             int pixel_shift = !!(desc->comp[0].depth_minus1 > 7);
++            int pixel_shift = !!(desc->comp[0].depth > 8);
 +
 +            ret = av_frame_ref(out, src);
 +            if (frame->flags & HEVC_FRAME_FLAG_BUMPING)
 +                ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT | HEVC_FRAME_FLAG_BUMPING);
 +            else
 +                ff_hevc_unref_frame(s, frame, HEVC_FRAME_FLAG_OUTPUT);
              if (ret < 0)
                  return ret;
  
@@@ -114,24 -94,24 +114,24 @@@ static inline int libopenjpeg_matches_p
      switch (desc->nb_components) {
      case 4:
          match = match &&
-                 desc->comp[3].depth_minus1 + 1 >= image->comps[3].prec &&
 -                desc->comp[3].depth >= img->comps[3].prec &&
 -                1 == img->comps[3].dx &&
 -                1 == img->comps[3].dy;
++                desc->comp[3].depth >= 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 &&
 -                desc->comp[2].depth >= 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 >= 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 &&
 -                desc->comp[1].depth >= 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 >= 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 &&
 -                desc->comp[0].depth >= img->comps[0].prec &&
 -                1 == img->comps[0].dx &&
 -                1 == img->comps[0].dy;
++                desc->comp[0].depth >= image->comps[0].prec &&
 +                1 == image->comps[0].dx &&
 +                1 == image->comps[0].dy;
      default:
          break;
      }
@@@ -378,17 -364,8 +378,17 @@@ static int libopenjpeg_decode_frame(AVC
          goto done;
      }
  
 +    for (i = 0; i < image->numcomps; i++) {
 +        if (!image->comps[i].data) {
 +            av_log(avctx, AV_LOG_ERROR,
 +                   "Image component %d contains no data.\n", i);
 +            ret = AVERROR_INVALIDDATA;
 +            goto done;
 +        }
 +    }
 +
      desc       = av_pix_fmt_desc_get(avctx->pix_fmt);
-     pixel_size = desc->comp[0].step_minus1 + 1;
+     pixel_size = desc->comp[0].step;
      ispacked   = libopenjpeg_ispacked(avctx->pix_fmt);
  
      switch (pixel_size) {
@@@ -188,14 -124,20 +188,14 @@@ static opj_image_t *mj2_create_image(AV
          return NULL;
      }
  
 -    cmptparm = av_mallocz(numcomps * sizeof(*cmptparm));
 -    if (!cmptparm) {
 -        av_log(avctx, AV_LOG_ERROR, "Not enough memory");
 -        return NULL;
 -    }
 -
      for (i = 0; i < numcomps; i++) {
-         cmptparm[i].prec = desc->comp[i].depth_minus1 + 1;
-         cmptparm[i].bpp  = desc->comp[i].depth_minus1 + 1;
+         cmptparm[i].prec = desc->comp[i].depth;
+         cmptparm[i].bpp  = desc->comp[i].depth;
          cmptparm[i].sgnd = 0;
 -        cmptparm[i].dx   = sub_dx[i];
 -        cmptparm[i].dy   = sub_dy[i];
 -        cmptparm[i].w    = avctx->width / sub_dx[i];
 -        cmptparm[i].h    = avctx->height / sub_dy[i];
 +        cmptparm[i].dx = sub_dx[i];
 +        cmptparm[i].dy = sub_dy[i];
 +        cmptparm[i].w = (avctx->width + sub_dx[i] - 1) / sub_dx[i];
 +        cmptparm[i].h = (avctx->height + sub_dy[i] - 1) / sub_dy[i];
      }
  
      img = opj_image_create(numcomps, cmptparm, color_space);
Simple merge
Simple merge
@@@ -269,9 -269,9 +269,9 @@@ static int config_input(AVFilterLink *i
  
      s->hsub  = desc->log2_chroma_w;
      s->vsub  = desc->log2_chroma_h;
-     s->depth = desc->comp[0].depth_minus1+1;
+     s->depth = desc->comp[0].depth;
  
 -    s->line = av_malloc(inlink->w * sizeof(*s->line));
 +    s->line = av_malloc_array(inlink->w, sizeof(*s->line));
      if (!s->line)
          return AVERROR(ENOMEM);
  
@@@ -186,10 -186,11 +186,10 @@@ static int filter_slice(AVFilterContex
      YADIFContext *s = ctx->priv;
      ThreadData *td  = arg;
      int refs = s->cur->linesize[td->plane];
-     int df = (s->csp->comp[td->plane].depth_minus1 + 8) / 8;
+     int df = (s->csp->comp[td->plane].depth + 7) / 8;
      int pix_3 = 3 * df;
 -    int slice_h = td->h / nb_jobs;
 -    int slice_start = jobnr * slice_h;
 -    int slice_end   = (jobnr == nb_jobs - 1) ? td->h : (jobnr + 1) * slice_h;
 +    int slice_start = (td->h *  jobnr   ) / nb_jobs;
 +    int slice_end   = (td->h * (jobnr+1)) / nb_jobs;
      int y;
  
      /* filtering reads 3 pixels to the left/right; to avoid invalid reads,
@@@ -477,16 -462,8 +477,16 @@@ static int config_props(AVFilterLink *l
      link->w             = link->src->inputs[0]->w;
      link->h             = link->src->inputs[0]->h;
  
 +    if(s->mode&1)
 +        link->frame_rate = av_mul_q(link->src->inputs[0]->frame_rate, (AVRational){2,1});
 +
 +    if (link->w < 3 || link->h < 3) {
 +        av_log(ctx, AV_LOG_ERROR, "Video of less than 3 columns or lines is not supported\n");
 +        return AVERROR(EINVAL);
 +    }
 +
      s->csp = av_pix_fmt_desc_get(link->format);
-     if (s->csp->comp[0].depth_minus1 / 8 == 1) {
+     if (s->csp->comp[0].depth > 8) {
          s->filter_line  = filter_line_c_16bit;
          s->filter_edges = filter_edges_16bit;
      } else {
Simple merge
@@@ -180,9 -182,9 +183,9 @@@ static const AVPixFmtDescriptor av_pix_
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 2, 3, 0, 7 },        /* R */
-             { 0, 2, 2, 0, 7 },        /* G */
-             { 0, 2, 1, 0, 7 },        /* B */
 -            { 0, 3, 0, 0, 8, 2, 7, 1 },        /* B */
 -            { 0, 3, 1, 0, 8, 2, 7, 2 },        /* G */
+             { 0, 3, 2, 0, 8, 2, 7, 3 },        /* R */
++            { 0, 3, 1, 0, 8, 2, 7, 2 },        /* G */
++            { 0, 3, 0, 0, 8, 2, 7, 1 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB,
      },
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR,
      },
-             { 0, 0, 1, 0, 7 },        /* Y */
-             { 1, 0, 1, 0, 7 },        /* U */
-             { 2, 0, 1, 0, 7 },        /* V */
 +    [AV_PIX_FMT_YUVJ411P] = {
 +        .name = "yuvj411p",
 +        .nb_components = 3,
 +        .log2_chroma_w = 2,
 +        .log2_chroma_h = 0,
 +        .comp = {
++            { 0, 1, 0, 0, 8, 0, 7, 1 },        /* Y */
++            { 1, 1, 0, 0, 8, 0, 7, 1 },        /* U */
++            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_GRAY8] = {
          .name = "gray",
          .nb_components = 1,
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 0, 1, 0, 2 },        /* R */
-             { 0, 0, 1, 3, 2 },        /* G */
-             { 0, 0, 1, 6, 1 },        /* B */
 -            { 0, 1, 0, 6, 2, 0, 1, 1 },        /* B */
 -            { 0, 1, 0, 3, 3, 0, 2, 1 },        /* G */
+             { 0, 1, 0, 0, 3, 0, 2, 1 },        /* R */
++            { 0, 1, 0, 3, 3, 0, 2, 1 },        /* G */
++            { 0, 1, 0, 6, 2, 0, 1, 1 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PSEUDOPAL,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 3, 4, 0, 0 },        /* R */
-             { 0, 3, 2, 0, 1 },        /* G */
-             { 0, 3, 1, 0, 0 },        /* B */
 -            { 0, 4, 0, 0, 1, 3, 0, 1 },        /* B */
 -            { 0, 4, 1, 0, 2, 3, 1, 2 },        /* G */
+             { 0, 4, 3, 0, 1, 3, 0, 4 },        /* R */
++            { 0, 4, 1, 0, 2, 3, 1, 2 },        /* G */
++            { 0, 4, 0, 0, 1, 3, 0, 1 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BITSTREAM | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 0, 1, 0, 0 },        /* R */
-             { 0, 0, 1, 1, 1 },        /* G */
-             { 0, 0, 1, 3, 0 },        /* B */
 -            { 0, 1, 0, 3, 1, 0, 0, 1 },        /* B */
 -            { 0, 1, 0, 1, 2, 0, 1, 1 },        /* G */
+             { 0, 1, 0, 0, 1, 0, 0, 1 },        /* R */
++            { 0, 1, 0, 1, 2, 0, 1, 1 },        /* G */
++            { 0, 1, 0, 3, 1, 0, 0, 1 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_PSEUDOPAL,
      },
          .log2_chroma_w = 1,
          .log2_chroma_h = 1,
          .comp = {
-             { 0, 0, 1, 0, 7 },        /* Y */
-             { 1, 1, 2, 0, 7 },        /* U */
-             { 1, 1, 1, 0, 7 },        /* V */
+             { 0, 1, 0, 0, 8, 0, 7, 1 },        /* Y */
 -            { 1, 2, 0, 0, 8, 1, 7, 1 },        /* V */
+             { 1, 2, 1, 0, 8, 1, 7, 2 },        /* U */
++            { 1, 2, 0, 0, 8, 1, 7, 1 },        /* V */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 3, 2, 0, 7 },        /* R */
-             { 0, 3, 3, 0, 7 },        /* G */
-             { 0, 3, 4, 0, 7 },        /* B */
-             { 0, 3, 1, 0, 7 },        /* A */
 -            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* A */
+             { 0, 4, 1, 0, 8, 3, 7, 2 },        /* R */
+             { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
+             { 0, 4, 3, 0, 8, 3, 7, 4 },        /* B */
++            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* A */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 3, 4, 0, 7 },        /* R */
-             { 0, 3, 3, 0, 7 },        /* G */
-             { 0, 3, 2, 0, 7 },        /* B */
-             { 0, 3, 1, 0, 7 },        /* A */
 -            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* A */
 -            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* B */
 -            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
+             { 0, 4, 3, 0, 8, 3, 7, 4 },        /* R */
++            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* B */
++            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* A */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 3, 3, 0, 7 },        /* R */
-             { 0, 3, 2, 0, 7 },        /* G */
-             { 0, 3, 1, 0, 7 },        /* B */
-             { 0, 3, 4, 0, 7 },        /* A */
 -            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* B */
 -            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
+             { 0, 4, 2, 0, 8, 3, 7, 3 },        /* R */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
++            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* B */
+             { 0, 4, 3, 0, 8, 3, 7, 4 },        /* A */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
-             { 0, 3, 2, 0, 7 },        /* R */
-             { 0, 3, 3, 0, 7 },        /* G */
-             { 0, 3, 4, 0, 7 },        /* B */
 +    [AV_PIX_FMT_0RGB] = {
 +        .name = "0rgb",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
-             { 0, 3, 1, 0, 7 },        /* R */
-             { 0, 3, 2, 0, 7 },        /* G */
-             { 0, 3, 3, 0, 7 },        /* B */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* R */
++            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
++            { 0, 4, 3, 0, 8, 3, 7, 4 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_RGB0] = {
 +        .name = "rgb0",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
-             { 0, 3, 4, 0, 7 },        /* R */
-             { 0, 3, 3, 0, 7 },        /* G */
-             { 0, 3, 2, 0, 7 },        /* B */
++            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* R */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
++            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_0BGR] = {
 +        .name = "0bgr",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
-             { 0, 3, 3, 0, 7 },        /* R */
-             { 0, 3, 2, 0, 7 },        /* G */
-             { 0, 3, 1, 0, 7 },        /* B */
++            { 0, 4, 3, 0, 8, 3, 7, 4 },        /* R */
++            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* G */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BGR0] = {
 +        .name = "bgr0",
 +        .nb_components= 3,
 +        .log2_chroma_w= 0,
 +        .log2_chroma_h= 0,
 +        .comp = {
++            { 0, 4, 2, 0, 8, 3, 7, 3 },        /* R */
++            { 0, 4, 1, 0, 8, 3, 7, 2 },        /* G */
++            { 0, 4, 0, 0, 8, 3, 7, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
      [AV_PIX_FMT_GRAY16BE] = {
          .name = "gray16be",
          .nb_components = 1,
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR,
      },
-             { 0, 1, 1, 0, 9 },        /* Y */
-             { 1, 1, 1, 0, 9 },        /* U */
-             { 2, 1, 1, 0, 9 },        /* V */
 +    [AV_PIX_FMT_YUV440P10LE] = {
 +        .name = "yuv440p10le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 9 },        /* Y */
-             { 1, 1, 1, 0, 9 },        /* U */
-             { 2, 1, 1, 0, 9 },        /* V */
++            { 0, 2, 0, 0, 10, 1, 9, 1 },        /* Y */
++            { 1, 2, 0, 0, 10, 1, 9, 1 },        /* U */
++            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P10BE] = {
 +        .name = "yuv440p10be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
++            { 0, 2, 0, 0, 10, 1, 9, 1 },        /* Y */
++            { 1, 2, 0, 0, 10, 1, 9, 1 },        /* U */
++            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P12LE] = {
 +        .name = "yuv440p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV440P12BE] = {
 +        .name = "yuv440p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 1,
 +        .comp = {
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUVA420P] = {
          .name = "yuva420p",
          .nb_components = 4,
          .log2_chroma_w = 1,
          .log2_chroma_h = 1,
          .comp = {
-             { 0, 1, 1, 0, 8 },        /* Y */
-             { 1, 1, 1, 0, 8 },        /* U */
-             { 2, 1, 1, 0, 8 },        /* V */
-             { 3, 1, 1, 0, 8 },        /* A */
+             { 0, 2, 0, 0, 9, 1, 8, 1 },        /* Y */
+             { 1, 2, 0, 0, 9, 1, 8, 1 },        /* U */
+             { 2, 2, 0, 0, 9, 1, 8, 1 },        /* V */
+             { 3, 2, 0, 0, 9, 1, 8, 1 },        /* A */
          },
 -        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_ALPHA,
      },
      [AV_PIX_FMT_YUVA420P9LE] = {
          .name = "yuva420p9le",
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 5, 5, 0, 15 },       /* R */
-             { 0, 5, 3, 0, 15 },       /* G */
-             { 0, 5, 1, 0, 15 },       /* B */
 -            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
 -            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
+             { 0, 6, 4, 0, 16, 5, 15, 5 },       /* R */
++            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
++            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 5, 5, 0, 15 },       /* R */
-             { 0, 5, 3, 0, 15 },       /* G */
-             { 0, 5, 1, 0, 15 },       /* B */
 -            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
 -            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
+             { 0, 6, 4, 0, 16, 5, 15, 5 },       /* R */
++            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
++            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 7, 5, 0, 15 },       /* R */
-             { 0, 7, 3, 0, 15 },       /* G */
-             { 0, 7, 1, 0, 15 },       /* B */
-             { 0, 7, 7, 0, 15 },       /* A */
 -            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
 -            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
 -            { 0, 6, 4, 0, 16, 5, 15, 5 },       /* R */
 -            { 0, 6, 6, 0, 16, 5, 15, 7 },       /* A */
++            { 0, 8, 4, 0, 16, 7, 15, 5 },       /* R */
++            { 0, 8, 2, 0, 16, 7, 15, 3 },       /* G */
++            { 0, 8, 0, 0, 16, 7, 15, 1 },       /* B */
++            { 0, 8, 6, 0, 16, 7, 15, 7 },       /* A */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 7, 5, 0, 15 },       /* R */
-             { 0, 7, 3, 0, 15 },       /* G */
-             { 0, 7, 1, 0, 15 },       /* B */
-             { 0, 7, 7, 0, 15 },       /* A */
 -            { 0, 6, 0, 0, 16, 5, 15, 1 },       /* B */
 -            { 0, 6, 2, 0, 16, 5, 15, 3 },       /* G */
 -            { 0, 6, 4, 0, 16, 5, 15, 5 },       /* R */
 -            { 0, 6, 6, 0, 16, 5, 15, 7 },       /* A */
++            { 0, 8, 4, 0, 16, 7, 15, 5 },       /* R */
++            { 0, 8, 2, 0, 16, 7, 15, 3 },       /* G */
++            { 0, 8, 0, 0, 16, 7, 15, 1 },       /* B */
++            { 0, 8, 6, 0, 16, 7, 15, 7 },       /* A */
          },
          .flags = AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 4 },        /* R */
-             { 0, 1, 1, 5, 5 },        /* G */
-             { 0, 1, 0, 3, 4 },        /* B */
 -            { 0, 2, -1, 3, 5, 1, 4, 0 },        /* B */
 -            { 0, 2,  0, 5, 6, 1, 5, 1 },        /* G */
+             { 0, 2,  0, 0, 5, 1, 4, 1 },        /* R */
++            { 0, 2,  0, 5, 6, 1, 5, 1 },        /* G */
++            { 0, 2, -1, 3, 5, 1, 4, 0 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 4 },        /* R */
-             { 0, 1, 1, 5, 5 },        /* G */
-             { 0, 1, 2, 3, 4 },        /* B */
 -            { 0, 2, 1, 3, 5, 1, 4, 2 },        /* B */
 -            { 0, 2, 0, 5, 6, 1, 5, 1 },        /* G */
+             { 0, 2, 0, 0, 5, 1, 4, 1 },        /* R */
++            { 0, 2, 0, 5, 6, 1, 5, 1 },        /* G */
++            { 0, 2, 1, 3, 5, 1, 4, 2 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 4 },       /* R */
-             { 0, 1, 1, 5, 4 },       /* G */
-             { 0, 1, 0, 2, 4 },       /* B */
 -            { 0, 2, -1, 2, 5, 1, 4, 0 },       /* B */
 -            { 0, 2,  0, 5, 5, 1, 4, 1 },       /* G */
+             { 0, 2,  0, 0, 5, 1, 4, 1 },       /* R */
++            { 0, 2,  0, 5, 5, 1, 4, 1 },       /* G */
++            { 0, 2, -1, 2, 5, 1, 4, 0 },       /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
       },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 4 },        /* R */
-             { 0, 1, 1, 5, 4 },        /* G */
-             { 0, 1, 2, 2, 4 },        /* B */
 -            { 0, 2, 1, 2, 5, 1, 4, 2 },        /* B */
 -            { 0, 2, 0, 5, 5, 1, 4, 1 },        /* G */
+             { 0, 2, 0, 0, 5, 1, 4, 1 },        /* R */
++            { 0, 2, 0, 5, 5, 1, 4, 1 },        /* G */
++            { 0, 2, 1, 2, 5, 1, 4, 2 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 3 },       /* R */
-             { 0, 1, 1, 4, 3 },       /* G */
-             { 0, 1, 0, 0, 3 },       /* B */
 -            { 0, 2, -1, 0, 4, 1, 3, 0 },       /* B */
 -            { 0, 2,  0, 4, 4, 1, 3, 1 },       /* G */
+             { 0, 2,  0, 0, 4, 1, 3, 1 },       /* R */
++            { 0, 2,  0, 4, 4, 1, 3, 1 },       /* G */
++            { 0, 2, -1, 0, 4, 1, 3, 0 },       /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
       },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 0, 1, 1, 0, 3 },        /* R */
-             { 0, 1, 1, 4, 3 },        /* G */
-             { 0, 1, 2, 0, 3 },        /* B */
 -            { 0, 2, 1, 0, 4, 1, 3, 2 },        /* B */
 -            { 0, 2, 0, 4, 4, 1, 3, 1 },        /* G */
+             { 0, 2, 0, 0, 4, 1, 3, 1 },        /* R */
++            { 0, 2, 0, 4, 4, 1, 3, 1 },        /* G */
++            { 0, 2, 1, 0, 4, 1, 3, 2 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_RGB,
      },
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
 +    [AV_PIX_FMT_YUV420P12LE] = {
 +        .name = "yuv420p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P12BE] = {
 +        .name = "yuv420p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P14LE] = {
 +        .name = "yuv420p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV420P14BE] = {
 +        .name = "yuv420p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 1,
 +        .comp = {
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUV420P16LE] = {
          .name = "yuv420p16le",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
 +    [AV_PIX_FMT_YUV422P12LE] = {
 +        .name = "yuv422p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P12BE] = {
 +        .name = "yuv422p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P14LE] = {
 +        .name = "yuv422p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV422P14BE] = {
 +        .name = "yuv422p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 1,
 +        .log2_chroma_h = 0,
 +        .comp = {
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_YUV422P16LE] = {
          .name = "yuv422p16le",
          .nb_components = 3,
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
      },
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
 +    [AV_PIX_FMT_YUV444P12LE] = {
 +        .name = "yuv444p12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 11 },        /* Y */
-             { 1, 1, 1, 0, 11 },        /* U */
-             { 2, 1, 1, 0, 11 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P12BE] = {
 +        .name = "yuv444p12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* Y */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* U */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P14LE] = {
 +        .name = "yuv444p14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 1, 1, 0, 13 },        /* Y */
-             { 1, 1, 1, 0, 13 },        /* U */
-             { 2, 1, 1, 0, 13 },        /* V */
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR,
 +    },
 +    [AV_PIX_FMT_YUV444P14BE] = {
 +        .name = "yuv444p14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* Y */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* U */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* V */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR,
 +    },
      [AV_PIX_FMT_D3D11VA_VLD] = {
          .name = "d3d11va_vld",
          .log2_chroma_w = 1,
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 0, 1, 0, 7 },        /* R */
-             { 0, 0, 1, 0, 7 },        /* G */
-             { 1, 0, 1, 0, 7 },        /* B */
++            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* R */
+             { 0, 1, 0, 0, 8, 0, 7, 1 },        /* G */
+             { 1, 1, 0, 0, 8, 0, 7, 1 },        /* B */
 -            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* R */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 8 },        /* R */
-             { 0, 1, 1, 0, 8 },        /* G */
-             { 1, 1, 1, 0, 8 },        /* B */
++            { 2, 2, 0, 0, 9, 1, 8, 1 },        /* R */
+             { 0, 2, 0, 0, 9, 1, 8, 1 },        /* G */
+             { 1, 2, 0, 0, 9, 1, 8, 1 },        /* B */
 -            { 2, 2, 0, 0, 9, 1, 8, 1 },        /* R */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 8 },        /* R */
-             { 0, 1, 1, 0, 8 },        /* G */
-             { 1, 1, 1, 0, 8 },        /* B */
++            { 2, 2, 0, 0, 9, 1, 8, 1 },        /* R */
+             { 0, 2, 0, 0, 9, 1, 8, 1 },        /* G */
+             { 1, 2, 0, 0, 9, 1, 8, 1 },        /* B */
 -            { 2, 2, 0, 0, 9, 1, 8, 1 },        /* R */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 9 },        /* R */
-             { 0, 1, 1, 0, 9 },        /* G */
-             { 1, 1, 1, 0, 9 },        /* B */
++            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* R */
+             { 0, 2, 0, 0, 10, 1, 9, 1 },        /* G */
+             { 1, 2, 0, 0, 10, 1, 9, 1 },        /* B */
 -            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* R */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 9 },        /* R */
-             { 0, 1, 1, 0, 9 },        /* G */
-             { 1, 1, 1, 0, 9 },        /* B */
++            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* R */
+             { 0, 2, 0, 0, 10, 1, 9, 1 },        /* G */
+             { 1, 2, 0, 0, 10, 1, 9, 1 },        /* B */
 -            { 2, 2, 0, 0, 10, 1, 9, 1 },        /* R */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP12LE] = {
 +        .name = "gbrp12le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 2, 1, 1, 0, 11 },        /* R */
-             { 0, 1, 1, 0, 11 },        /* G */
-             { 1, 1, 1, 0, 11 },        /* B */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* R */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* G */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP12BE] = {
 +        .name = "gbrp12be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 2, 1, 1, 0, 11 },        /* R */
-             { 0, 1, 1, 0, 11 },        /* G */
-             { 1, 1, 1, 0, 11 },        /* B */
++            { 2, 2, 0, 0, 12, 1, 11, 1 },        /* R */
++            { 0, 2, 0, 0, 12, 1, 11, 1 },        /* G */
++            { 1, 2, 0, 0, 12, 1, 11, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP14LE] = {
 +        .name = "gbrp14le",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 2, 1, 1, 0, 13 },        /* R */
-             { 0, 1, 1, 0, 13 },        /* G */
-             { 1, 1, 1, 0, 13 },        /* B */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* R */
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* G */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* B */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_GBRP14BE] = {
 +        .name = "gbrp14be",
 +        .nb_components = 3,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 2, 1, 1, 0, 13 },        /* R */
-             { 0, 1, 1, 0, 13 },        /* G */
-             { 1, 1, 1, 0, 13 },        /* B */
++            { 2, 2, 0, 0, 14, 1, 13, 1 },        /* R */
++            { 0, 2, 0, 0, 14, 1, 13, 1 },        /* G */
++            { 1, 2, 0, 0, 14, 1, 13, 1 },        /* B */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 15 },       /* R */
-             { 0, 1, 1, 0, 15 },       /* G */
-             { 1, 1, 1, 0, 15 },       /* B */
++            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 0, 2, 0, 0, 16, 1, 15, 1 },       /* G */
+             { 1, 2, 0, 0, 16, 1, 15, 1 },       /* B */
 -            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 15 },       /* R */
-             { 0, 1, 1, 0, 15 },       /* G */
-             { 1, 1, 1, 0, 15 },       /* B */
++            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 0, 2, 0, 0, 16, 1, 15, 1 },       /* G */
+             { 1, 2, 0, 0, 16, 1, 15, 1 },       /* B */
 -            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB,
      },
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 0, 1, 0, 7 },        /* R */
-             { 0, 0, 1, 0, 7 },        /* G */
-             { 1, 0, 1, 0, 7 },        /* B */
-             { 3, 0, 1, 0, 7 },        /* A */
++            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* R */
+             { 0, 1, 0, 0, 8, 0, 7, 1 },        /* G */
+             { 1, 1, 0, 0, 8, 0, 7, 1 },        /* B */
 -            { 2, 1, 0, 0, 8, 0, 7, 1 },        /* R */
+             { 3, 1, 0, 0, 8, 0, 7, 1 },        /* A */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB |
                   AV_PIX_FMT_FLAG_ALPHA,
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 15 },       /* R */
-             { 0, 1, 1, 0, 15 },       /* G */
-             { 1, 1, 1, 0, 15 },       /* B */
-             { 3, 1, 1, 0, 15 },       /* A */
++            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 0, 2, 0, 0, 16, 1, 15, 1 },       /* G */
+             { 1, 2, 0, 0, 16, 1, 15, 1 },       /* B */
 -            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 3, 2, 0, 0, 16, 1, 15, 1 },       /* A */
          },
          .flags = AV_PIX_FMT_FLAG_PLANAR | AV_PIX_FMT_FLAG_RGB |
                   AV_PIX_FMT_FLAG_ALPHA,
          .log2_chroma_w = 0,
          .log2_chroma_h = 0,
          .comp = {
-             { 2, 1, 1, 0, 15 },       /* R */
-             { 0, 1, 1, 0, 15 },       /* G */
-             { 1, 1, 1, 0, 15 },       /* B */
-             { 3, 1, 1, 0, 15 },       /* A */
++            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 0, 2, 0, 0, 16, 1, 15, 1 },       /* G */
+             { 1, 2, 0, 0, 16, 1, 15, 1 },       /* B */
 -            { 2, 2, 0, 0, 16, 1, 15, 1 },       /* R */
+             { 3, 2, 0, 0, 16, 1, 15, 1 },       /* A */
          },
          .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_PLANAR |
                   AV_PIX_FMT_FLAG_RGB | AV_PIX_FMT_FLAG_ALPHA,
         },
          .flags = AV_PIX_FMT_FLAG_BE,
      },
-             {0,0,0,0,1},   \
-             {0,0,0,0,3},   \
-             {0,0,0,0,1},   \
 +
 +#define BAYER8_DESC_COMMON \
 +        .nb_components= 3, \
 +        .log2_chroma_w= 0, \
 +        .log2_chroma_h= 0, \
 +        .comp = {          \
-             {0,1,0,0, 3},  \
-             {0,1,0,0, 7},  \
-             {0,1,0,0, 3},  \
++            {0,1,0,0,2,0,1,1},\
++            {0,1,0,0,4,0,3,1},\
++            {0,1,0,0,2,0,1,1},\
 +        },                 \
 +
 +#define BAYER16_DESC_COMMON \
 +        .nb_components= 3, \
 +        .log2_chroma_w= 0, \
 +        .log2_chroma_h= 0, \
 +        .comp = {          \
++            {0,2,0,0,4,1,3,1},\
++            {0,2,0,0,8,1,7,1},\
++            {0,2,0,0,4,1,3,1},\
 +        },                 \
 +
 +    [AV_PIX_FMT_BAYER_BGGR8] = {
 +        .name = "bayer_bggr8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_BGGR16LE] = {
 +        .name = "bayer_bggr16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_BGGR16BE] = {
 +        .name = "bayer_bggr16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB8] = {
 +        .name = "bayer_rggb8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB16LE] = {
 +        .name = "bayer_rggb16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_RGGB16BE] = {
 +        .name = "bayer_rggb16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG8] = {
 +        .name = "bayer_gbrg8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG16LE] = {
 +        .name = "bayer_gbrg16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GBRG16BE] = {
 +        .name = "bayer_gbrg16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG8] = {
 +        .name = "bayer_grbg8",
 +        BAYER8_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG16LE] = {
 +        .name = "bayer_grbg16le",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_RGB,
 +    },
 +    [AV_PIX_FMT_BAYER_GRBG16BE] = {
 +        .name = "bayer_grbg16be",
 +        BAYER16_DESC_COMMON
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_RGB,
 +    },
      [AV_PIX_FMT_NV16] = {
          .name = "nv16",
          .nb_components = 3,
          .name = "mmal",
          .flags = AV_PIX_FMT_FLAG_HWACCEL,
      },
-             { 0, 7, 3, 0, 15 },        /* Y */
-             { 0, 7, 5, 0, 15 },        /* U */
-             { 0, 7, 7, 0, 15 },        /* V */
-             { 0, 7, 1, 0, 15 },        /* A */
 +    [AV_PIX_FMT_AYUV64LE] = {
 +        .name = "ayuv64le",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
-             { 0, 7, 3, 0, 15 },        /* Y */
-             { 0, 7, 5, 0, 15 },        /* U */
-             { 0, 7, 7, 0, 15 },        /* V */
-             { 0, 7, 1, 0, 15 },        /* A */
++            { 0, 8, 2, 0, 16, 7, 15, 3 },        /* Y */
++            { 0, 8, 4, 0, 16, 7, 15, 5 },        /* U */
++            { 0, 8, 6, 0, 16, 7, 15, 7 },        /* V */
++            { 0, 8, 0, 0, 16, 7, 15, 1 },        /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_ALPHA,
 +    },
 +    [AV_PIX_FMT_AYUV64BE] = {
 +        .name = "ayuv64be",
 +        .nb_components = 4,
 +        .log2_chroma_w = 0,
 +        .log2_chroma_h = 0,
 +        .comp = {
++            { 0, 8, 2, 0, 16, 7, 15, 3 },        /* Y */
++            { 0, 8, 4, 0, 16, 7, 15, 5 },        /* U */
++            { 0, 8, 6, 0, 16, 7, 15, 7 },        /* V */
++            { 0, 8, 0, 0, 16, 7, 15, 1 },        /* A */
 +        },
 +        .flags = AV_PIX_FMT_FLAG_BE | AV_PIX_FMT_FLAG_ALPHA,
 +    },
  };
+ #if FF_API_PLUS1_MINUS1
+ FF_ENABLE_DEPRECATION_WARNINGS
+ #endif
  
  static const char *color_range_names[AVCOL_RANGE_NB] = {
      "unknown", "tv", "pc",
@@@ -26,6 -26,6 +26,7 @@@
  
  #include "attributes.h"
  #include "pixfmt.h"
++#include "version.h"
  
  typedef struct AVComponentDescriptor {
      /**
  #ifndef FF_API_CRYPTO_CONTEXT
  #define FF_API_CRYPTO_CONTEXT           (LIBAVUTIL_VERSION_MAJOR < 56)
  #endif
 +#ifndef FF_API_VAAPI
 +#define FF_API_VAAPI                    (LIBAVUTIL_VERSION_MAJOR < 56)
 +#endif
 +#ifndef FF_API_FRAME_QP
 +#define FF_API_FRAME_QP                 (LIBAVUTIL_VERSION_MAJOR < 56)
 +#endif
+ #ifndef FF_API_PLUS1_MINUS1
+ #define FF_API_PLUS1_MINUS1             (LIBAVUTIL_VERSION_MAJOR < 56)
+ #endif
  
  /**
   * @}
@@@ -1845,8 -1279,7 +1845,8 @@@ yuv2gbrp_full_X_c(SwsContext *c, const 
      int i;
      int hasAlpha = (desc->flags & AV_PIX_FMT_FLAG_ALPHA) && alpSrc;
      uint16_t **dest16 = (uint16_t**)dest;
-     int SH = 22 + 7 - desc->comp[0].depth_minus1;
+     int SH = 22 + 8 - desc->comp[0].depth;
 +    int A = 0; // init to silence warning
  
      for (i = 0; i < dstW; i++) {
          int j;
@@@ -2073,20 -1366,13 +2073,20 @@@ av_cold void ff_sws_init_output_funcs(S
          *yuv2planeX = isBE(dstFormat) ? yuv2planeX_16BE_c  : yuv2planeX_16LE_c;
          *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_16BE_c  : yuv2plane1_16LE_c;
      } else if (is9_OR_10BPS(dstFormat)) {
-         if (desc->comp[0].depth_minus1 == 8) {
+         if (desc->comp[0].depth == 9) {
              *yuv2planeX = isBE(dstFormat) ? yuv2planeX_9BE_c  : yuv2planeX_9LE_c;
              *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_9BE_c  : yuv2plane1_9LE_c;
 -        } else {
 +        } else if (desc->comp[0].depth_minus1 == 9) {
              *yuv2planeX = isBE(dstFormat) ? yuv2planeX_10BE_c  : yuv2planeX_10LE_c;
              *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_10BE_c  : yuv2plane1_10LE_c;
 -        }
 +        } else if (desc->comp[0].depth_minus1 == 11) {
 +            *yuv2planeX = isBE(dstFormat) ? yuv2planeX_12BE_c  : yuv2planeX_12LE_c;
 +            *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_12BE_c  : yuv2plane1_12LE_c;
 +        } else if (desc->comp[0].depth_minus1 == 13) {
 +            *yuv2planeX = isBE(dstFormat) ? yuv2planeX_14BE_c  : yuv2planeX_14LE_c;
 +            *yuv2plane1 = isBE(dstFormat) ? yuv2plane1_14BE_c  : yuv2plane1_14LE_c;
 +        } else
 +            av_assert0(0);
      } else {
          *yuv2plane1 = yuv2plane1_8_c;
          *yuv2planeX = yuv2planeX_8_c;
@@@ -87,12 -91,9 +87,12 @@@ static void hScale16To19_c(SwsContext *
      int i;
      int32_t *dst        = (int32_t *) _dst;
      const uint16_t *src = (const uint16_t *) _src;
-     int bits            = desc->comp[0].depth_minus1;
+     int bits            = desc->comp[0].depth - 1;
      int sh              = bits - 4;
  
 +    if((isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8) && desc->comp[0].depth_minus1<15)
 +        sh= 9;
 +
      for (i = 0; i < dstW; i++) {
          int j;
          int srcPos = filterPos[i];
@@@ -113,11 -114,8 +113,11 @@@ static void hScale16To15_c(SwsContext *
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(c->srcFormat);
      int i;
      const uint16_t *src = (const uint16_t *) _src;
-     int sh              = desc->comp[0].depth_minus1;
+     int sh              = desc->comp[0].depth - 1;
  
 +    if(sh<15)
 +        sh= isAnyRGB(c->srcFormat) || c->srcFormat==AV_PIX_FMT_PAL8 ? 13 : desc->comp[0].depth_minus1;
 +
      for (i = 0; i < dstW; i++) {
          int j;
          int srcPos = filterPos[i];
@@@ -792,12 -692,14 +792,12 @@@ static int swscale(SwsContext *c, cons
      if (isPlanar(dstFormat) && isALPHA(dstFormat) && !alpPixBuf) {
          int length = dstW;
          int height = dstY - lastDstY;
 -        if (is16BPS(c->dstFormat))
 -            length *= 2;
  
 -        if (is9_OR_10BPS(dstFormat)) {
 +        if (is16BPS(dstFormat) || isNBPS(dstFormat)) {
              const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(dstFormat);
 -            fill_plane9or10(dst[3], dstStride[3], length, height, lastDstY,
 -                            255, desc->comp[3].depth, isBE(dstFormat));
 +            fillPlane16(dst[3], dstStride[3], length, height, lastDstY,
-                     1, desc->comp[3].depth_minus1,
++                    1, desc->comp[3].depth,
 +                    isBE(dstFormat));
          } else
              fillPlane(dst[3], dstStride[3], length, height, lastDstY, 255);
      }
@@@ -658,11 -569,9 +658,11 @@@ static av_always_inline int is9_OR_10BP
  {
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
      av_assert0(desc);
-     return desc->comp[0].depth_minus1 >= 8 && desc->comp[0].depth_minus1 <= 13;
 -    return desc->comp[0].depth == 9 || desc->comp[0].depth == 10;
++    return desc->comp[0].depth >= 9 && desc->comp[0].depth <= 14;
  }
  
 +#define isNBPS(x) is9_OR_10BPS(x)
 +
  static av_always_inline int isBE(enum AVPixelFormat pix_fmt)
  {
      const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(pix_fmt);
@@@ -893,170 -741,4 +893,170 @@@ void ff_sws_init_output_funcs(SwsContex
  void ff_sws_init_swscale_ppc(SwsContext *c);
  void ff_sws_init_swscale_x86(SwsContext *c);
  
-     int v = alpha ? 0xFFFF>>(15-bits) : (1<<bits);
 +void ff_hyscale_fast_c(SwsContext *c, int16_t *dst, int dstWidth,
 +                       const uint8_t *src, int srcW, int xInc);
 +void ff_hcscale_fast_c(SwsContext *c, int16_t *dst1, int16_t *dst2,
 +                       int dstWidth, const uint8_t *src1,
 +                       const uint8_t *src2, int srcW, int xInc);
 +int ff_init_hscaler_mmxext(int dstW, int xInc, uint8_t *filterCode,
 +                           int16_t *filter, int32_t *filterPos,
 +                           int numSplits);
 +void ff_hyscale_fast_mmxext(SwsContext *c, int16_t *dst,
 +                            int dstWidth, const uint8_t *src,
 +                            int srcW, int xInc);
 +void ff_hcscale_fast_mmxext(SwsContext *c, int16_t *dst1, int16_t *dst2,
 +                            int dstWidth, const uint8_t *src1,
 +                            const uint8_t *src2, int srcW, int xInc);
 +
 +/**
 + * Allocate and return an SwsContext.
 + * This is like sws_getContext() but does not perform the init step, allowing
 + * the user to set additional AVOptions.
 + *
 + * @see sws_getContext()
 + */
 +struct SwsContext *sws_alloc_set_opts(int srcW, int srcH, enum AVPixelFormat srcFormat,
 +                                      int dstW, int dstH, enum AVPixelFormat dstFormat,
 +                                      int flags, const double *param);
 +
 +int ff_sws_alphablendaway(SwsContext *c, const uint8_t *src[],
 +                          int srcStride[], int srcSliceY, int srcSliceH,
 +                          uint8_t *dst[], int dstStride[]);
 +
 +static inline void fillPlane16(uint8_t *plane, int stride, int width, int height, int y,
 +                               int alpha, int bits, const int big_endian)
 +{
 +    int i, j;
 +    uint8_t *ptr = plane + stride * y;
++    int v = alpha ? 0xFFFF>>(16-bits) : (1<<(bits-1));
 +    for (i = 0; i < height; i++) {
 +#define FILL(wfunc) \
 +        for (j = 0; j < width; j++) {\
 +            wfunc(ptr+2*j, v);\
 +        }
 +        if (big_endian) {
 +            FILL(AV_WB16);
 +        } else {
 +            FILL(AV_WL16);
 +        }
 +        ptr += stride;
 +    }
 +}
 +
 +#define MAX_SLICE_PLANES 4
 +
 +/// Slice plane
 +typedef struct SwsPlane
 +{
 +    int available_lines;    ///< max number of lines that can be hold by this plane
 +    int sliceY;             ///< index of first line
 +    int sliceH;             ///< number of lines
 +    uint8_t **line;         ///< line buffer
 +    uint8_t **tmp;          ///< Tmp line buffer used by mmx code
 +} SwsPlane;
 +
 +/**
 + * Struct which defines a slice of an image to be scaled or a output for
 + * a scaled slice.
 + * A slice can also be used as intermediate ring buffer for scaling steps.
 + */
 +typedef struct SwsSlice
 +{
 +    int width;              ///< Slice line width
 +    int h_chr_sub_sample;   ///< horizontal chroma subsampling factor
 +    int v_chr_sub_sample;   ///< vertical chroma subsampling factor
 +    int is_ring;            ///< flag to identify if this slice is a ring buffer
 +    int should_free_lines;  ///< flag to identify if there are dynamic allocated lines
 +    enum AVPixelFormat fmt; ///< planes pixel format
 +    SwsPlane plane[MAX_SLICE_PLANES];   ///< color planes
 +} SwsSlice;
 +
 +/**
 + * Struct which holds all necessary data for processing a slice.
 + * A processing step can be a color conversion or horizontal/vertical scaling.
 + */
 +typedef struct SwsFilterDescriptor
 +{
 +    SwsSlice *src;  ///< Source slice
 +    SwsSlice *dst;  ///< Output slice
 +
 +    int alpha;      ///< Flag for processing alpha channel
 +    void *instance; ///< Filter instance data
 +
 +    /// Function for processing input slice sliceH lines starting from line sliceY
 +    int (*process)(SwsContext *c, struct SwsFilterDescriptor *desc, int sliceY, int sliceH);
 +} SwsFilterDescriptor;
 +
 +/// Color conversion instance data
 +typedef struct ColorContext
 +{
 +    uint32_t *pal;
 +} ColorContext;
 +
 +/// Scaler instance data
 +typedef struct FilterContext
 +{
 +    uint16_t *filter;
 +    int *filter_pos;
 +    int filter_size;
 +    int xInc;
 +} FilterContext;
 +
 +typedef struct VScalerContext
 +{
 +    uint16_t *filter[2];
 +    int32_t  *filter_pos;
 +    int filter_size;
 +    int isMMX;
 +    void *pfn;
 +} VScalerContext;
 +
 +// warp input lines in the form (src + width*i + j) to slice format (line[i][j])
 +int ff_init_slice_from_src(SwsSlice * s, uint8_t *src[4], int stride[4], int srcW, int lumY, int lumH, int chrY, int chrH);
 +
 +// Initialize scaler filter descriptor chain
 +int ff_init_filters(SwsContext *c);
 +
 +// Free all filter data
 +int ff_free_filters(SwsContext *c);
 +
 +/*
 + function for applying ring buffer logic into slice s
 + It checks if the slice can hold more @lum lines, if yes
 + do nothing otherwise remove @lum least used lines.
 + It applies the same procedure for @chr lines.
 +*/
 +int ff_rotate_slice(SwsSlice *s, int lum, int chr);
 +
 +/// initializes gamma conversion descriptor
 +int ff_init_gamma_convert(SwsFilterDescriptor *desc, SwsSlice * src, uint16_t *table);
 +
 +/// initializes lum pixel format conversion descriptor
 +int ff_init_desc_fmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);
 +
 +/// initializes lum horizontal scaling descriptor
 +int ff_init_desc_hscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
 +
 +/// initializes chr pixel format conversion descriptor
 +int ff_init_desc_cfmt_convert(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst, uint32_t *pal);
 +
 +/// initializes chr horizontal scaling descriptor
 +int ff_init_desc_chscale(SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst, uint16_t *filter, int * filter_pos, int filter_size, int xInc);
 +
 +int ff_init_desc_no_chr(SwsFilterDescriptor *desc, SwsSlice * src, SwsSlice *dst);
 +
 +/// initializes vertical scaling descriptors
 +int ff_init_vscale(SwsContext *c, SwsFilterDescriptor *desc, SwsSlice *src, SwsSlice *dst);
 +
 +/// setup vertical scaler functions
 +void ff_init_vscale_pfn(SwsContext *c, yuv2planar1_fn yuv2plane1, yuv2planarX_fn yuv2planeX,
 +    yuv2interleavedX_fn yuv2nv12cX, yuv2packed1_fn yuv2packed1, yuv2packed2_fn yuv2packed2,
 +    yuv2packedX_fn yuv2packedX, yuv2anyX_fn yuv2anyX, int use_mmx);
 +
 +//number of extra lines to process
 +#define MAX_LINES_AHEAD 4
 +
 +// enable use of refactored scaler code
 +#define NEW_FILTER
 +
  #endif /* SWSCALE_SWSCALE_INTERNAL_H */
@@@ -1415,117 -810,185 +1415,117 @@@ static int planarCopyWrapper(SwsContex
          // ignore palette for GRAY8
          if (plane == 1 && !dst[2]) continue;
          if (!src[plane] || (plane == 1 && !src[2])) {
 -            int val = (plane == 3) ? 255 : 128;
 -            if (is16BPS(c->dstFormat))
 -                length *= 2;
 -            if (is9_OR_10BPS(c->dstFormat)) {
 -                fill_plane9or10(dst[plane], dstStride[plane],
 -                                length, height, y, val,
 -                                desc_dst->comp[plane].depth,
 -                                isBE(c->dstFormat));
 -            } else
 +            if (is16BPS(c->dstFormat) || isNBPS(c->dstFormat)) {
 +                fillPlane16(dst[plane], dstStride[plane], length, height, y,
-                         plane == 3, desc_dst->comp[plane].depth_minus1,
++                        plane == 3, desc_dst->comp[plane].depth,
 +                        isBE(c->dstFormat));
 +            } else {
                  fillPlane(dst[plane], dstStride[plane], length, height, y,
 -                          val);
 +                        (plane == 3) ? 255 : 128);
 +            }
          } else {
 -            if (is9_OR_10BPS(c->srcFormat)) {
 +            if(isNBPS(c->srcFormat) || isNBPS(c->dstFormat)
 +               || (is16BPS(c->srcFormat) != is16BPS(c->dstFormat))
 +            ) {
-                 const int src_depth = desc_src->comp[plane].depth_minus1 + 1;
-                 const int dst_depth = desc_dst->comp[plane].depth_minus1 + 1;
+                 const int src_depth = desc_src->comp[plane].depth;
+                 const int dst_depth = desc_dst->comp[plane].depth;
                  const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 +                uint16_t *dstPtr2 = (uint16_t*)dstPtr;
  
 -                if (is16BPS(c->dstFormat)) {
 -                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -#define COPY9_OR_10TO16(rfunc, wfunc) \
 -                    if (shiftonly) { \
 -                        for (i = 0; i < height; i++) { \
 -                            for (j = 0; j < length; j++) { \
 -                                int srcpx = rfunc(&srcPtr2[j]); \
 -                                wfunc(&dstPtr2[j], srcpx << (16 - src_depth)); \
 -                            } \
 -                            dstPtr2 += dstStride[plane] / 2; \
 -                            srcPtr2 += srcStride[plane] / 2; \
 -                        } \
 -                    } else { \
 -                        for (i = 0; i < height; i++) { \
 -                            for (j = 0; j < length; j++) { \
 -                                int srcpx = rfunc(&srcPtr2[j]); \
 -                                wfunc(&dstPtr2[j], (srcpx << (16 - src_depth)) | (srcpx >> (2 * src_depth - 16))); \
 -                            } \
 -                            dstPtr2 += dstStride[plane] / 2; \
 -                            srcPtr2 += srcStride[plane] / 2; \
 -                        } \
 +                if (dst_depth == 8) {
 +                    if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
 +                        DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, , )
 +                    } else {
 +                        DITHER_COPY(dstPtr, dstStride[plane], srcPtr2, srcStride[plane]/2, av_bswap16, )
                      }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO16(AV_RB16, AV_WB16);
 -                        } else {
 -                            COPY9_OR_10TO16(AV_RL16, AV_WB16);
 +                } else if (src_depth == 8) {
 +                    for (i = 0; i < height; i++) {
 +                        #define COPY816(w)\
 +                        if (shiftonly) {\
 +                            for (j = 0; j < length; j++)\
 +                                w(&dstPtr2[j], srcPtr[j]<<(dst_depth-8));\
 +                        } else {\
 +                            for (j = 0; j < length; j++)\
 +                                w(&dstPtr2[j], (srcPtr[j]<<(dst_depth-8)) |\
 +                                               (srcPtr[j]>>(2*8-dst_depth)));\
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO16(AV_RB16, AV_WL16);
 +                        if(isBE(c->dstFormat)){
 +                            COPY816(AV_WB16)
                          } else {
 -                            COPY9_OR_10TO16(AV_RL16, AV_WL16);
 +                            COPY816(AV_WL16)
                          }
 +                        dstPtr2 += dstStride[plane]/2;
 +                        srcPtr  += srcStride[plane];
                      }
 -                } else if (is9_OR_10BPS(c->dstFormat)) {
 -                    uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -#define COPY9_OR_10TO9_OR_10(loop) \
 -                    for (i = 0; i < height; i++) { \
 -                        for (j = 0; j < length; j++) { \
 -                            loop; \
 -                        } \
 -                        dstPtr2 += dstStride[plane] / 2; \
 -                        srcPtr2 += srcStride[plane] / 2; \
 -                    }
 -#define COPY9_OR_10TO9_OR_10_2(rfunc, wfunc) \
 -                    if (dst_depth > src_depth) { \
 -                        COPY9_OR_10TO9_OR_10(int srcpx = rfunc(&srcPtr2[j]); \
 -                            wfunc(&dstPtr2[j], (srcpx << 1) | (srcpx >> 9))); \
 -                    } else if (dst_depth < src_depth) { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_1, 1, clip9); \
 -                    } else { \
 -                        COPY9_OR_10TO9_OR_10(wfunc(&dstPtr2[j], rfunc(&srcPtr2[j]))); \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WB16);
 -                        } else {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WB16);
 +                } else if (src_depth <= dst_depth) {
 +                    for (i = 0; i < height; i++) {
 +                        j = 0;
 +                        if(isBE(c->srcFormat) == HAVE_BIGENDIAN &&
 +                           isBE(c->dstFormat) == HAVE_BIGENDIAN &&
 +                           shiftonly) {
 +                             unsigned shift = dst_depth - src_depth;
 +#if HAVE_FAST_64BIT
 +#define FAST_COPY_UP(shift) \
 +    for (; j < length - 3; j += 4) { \
 +        uint64_t v = AV_RN64A(srcPtr2 + j); \
 +        AV_WN64A(dstPtr2 + j, v << shift); \
 +    }
 +#else
 +#define FAST_COPY_UP(shift) \
 +    for (; j < length - 1; j += 2) { \
 +        uint32_t v = AV_RN32A(srcPtr2 + j); \
 +        AV_WN32A(dstPtr2 + j, v << shift); \
 +    }
 +#endif
 +                             switch (shift)
 +                             {
 +                             case 6: FAST_COPY_UP(6); break;
 +                             case 7: FAST_COPY_UP(7); break;
 +                             }
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RB16, AV_WL16);
 +#define COPY_UP(r,w) \
 +    if(shiftonly){\
 +        for (; j < length; j++){ \
 +            unsigned int v= r(&srcPtr2[j]);\
 +            w(&dstPtr2[j], v<<(dst_depth-src_depth));\
 +        }\
 +    }else{\
 +        for (; j < length; j++){ \
 +            unsigned int v= r(&srcPtr2[j]);\
 +            w(&dstPtr2[j], (v<<(dst_depth-src_depth)) | \
 +                        (v>>(2*src_depth-dst_depth)));\
 +        }\
 +    }
 +                        if(isBE(c->srcFormat)){
 +                            if(isBE(c->dstFormat)){
 +                                COPY_UP(AV_RB16, AV_WB16)
 +                            } else {
 +                                COPY_UP(AV_RB16, AV_WL16)
 +                            }
                          } else {
 -                            COPY9_OR_10TO9_OR_10_2(AV_RL16, AV_WL16);
 +                            if(isBE(c->dstFormat)){
 +                                COPY_UP(AV_RL16, AV_WB16)
 +                            } else {
 +                                COPY_UP(AV_RL16, AV_WL16)
 +                            }
                          }
 +                        dstPtr2 += dstStride[plane]/2;
 +                        srcPtr2 += srcStride[plane]/2;
                      }
                  } else {
 -#define W8(a, b) { *(a) = (b); }
 -#define COPY9_OR_10TO8(rfunc) \
 -                    if (src_depth == 9) { \
 -                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_1, 1, av_clip_uint8); \
 -                    } else { \
 -                        DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_3, 2, av_clip_uint8); \
 -                    }
 -                    if (isBE(c->srcFormat)) {
 -                        COPY9_OR_10TO8(AV_RB16);
 -                    } else {
 -                        COPY9_OR_10TO8(AV_RL16);
 -                    }
 -                }
 -            } else if (is9_OR_10BPS(c->dstFormat)) {
 -                const int dst_depth = desc_dst->comp[plane].depth;
 -                uint16_t *dstPtr2 = (uint16_t *) dstPtr;
 -
 -                if (is16BPS(c->srcFormat)) {
 -                    const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 -#define COPY16TO9_OR_10(rfunc, wfunc) \
 -                    if (dst_depth == 9) { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    ff_dither_8x8_128, 7, clip9); \
 -                    } else { \
 -                        DITHER_COPY(dstPtr2, dstStride[plane] / 2, wfunc, \
 -                                    srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                    dither_8x8_64, 6, clip10); \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY16TO9_OR_10(AV_RB16, AV_WB16);
 +                    if(isBE(c->srcFormat) == HAVE_BIGENDIAN){
 +                        if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , )
                          } else {
 -                            COPY16TO9_OR_10(AV_RL16, AV_WB16);
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, , av_bswap16)
                          }
 -                    } else {
 -                        if (isBE(c->srcFormat)) {
 -                            COPY16TO9_OR_10(AV_RB16, AV_WL16);
 +                    }else{
 +                        if(isBE(c->dstFormat) == HAVE_BIGENDIAN){
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, )
                          } else {
 -                            COPY16TO9_OR_10(AV_RL16, AV_WL16);
 +                            DITHER_COPY(dstPtr2, dstStride[plane]/2, srcPtr2, srcStride[plane]/2, av_bswap16, av_bswap16)
                          }
                      }
 -                } else /* 8bit */ {
 -#define COPY8TO9_OR_10(wfunc) \
 -                    if (shiftonly) { \
 -                        for (i = 0; i < height; i++) { \
 -                            for (j = 0; j < length; j++) { \
 -                                const int srcpx = srcPtr[j]; \
 -                                wfunc(&dstPtr2[j], srcpx << (dst_depth - 8)); \
 -                            } \
 -                            dstPtr2 += dstStride[plane] / 2; \
 -                            srcPtr  += srcStride[plane]; \
 -                        } \
 -                    } else { \
 -                        for (i = 0; i < height; i++) { \
 -                            for (j = 0; j < length; j++) { \
 -                                const int srcpx = srcPtr[j]; \
 -                                wfunc(&dstPtr2[j], (srcpx << (dst_depth - 8)) | (srcpx >> (16 - dst_depth))); \
 -                            } \
 -                            dstPtr2 += dstStride[plane] / 2; \
 -                            srcPtr  += srcStride[plane]; \
 -                        } \
 -                    }
 -                    if (isBE(c->dstFormat)) {
 -                        COPY8TO9_OR_10(AV_WB16);
 -                    } else {
 -                        COPY8TO9_OR_10(AV_WL16);
 -                    }
 -                }
 -            } else if (is16BPS(c->srcFormat) && !is16BPS(c->dstFormat)) {
 -                const uint16_t *srcPtr2 = (const uint16_t *) srcPtr;
 -#define COPY16TO8(rfunc) \
 -                    DITHER_COPY(dstPtr,  dstStride[plane],   W8, \
 -                                srcPtr2, srcStride[plane] / 2, rfunc, \
 -                                dither_8x8_256, 8, av_clip_uint8);
 -                if (isBE(c->srcFormat)) {
 -                    COPY16TO8(AV_RB16);
 -                } else {
 -                    COPY16TO8(AV_RL16);
 -                }
 -            } else if (!is16BPS(c->srcFormat) && is16BPS(c->dstFormat)) {
 -                for (i = 0; i < height; i++) {
 -                    for (j = 0; j < length; j++) {
 -                        dstPtr[ j << 1     ] = srcPtr[j];
 -                        dstPtr[(j << 1) + 1] = srcPtr[j];
 -                    }
 -                    srcPtr += srcStride[plane];
 -                    dstPtr += dstStride[plane];
                  }
              } else if (is16BPS(c->srcFormat) && is16BPS(c->dstFormat) &&
                        isBE(c->srcFormat) != isBE(c->dstFormat)) {
@@@ -1624,31 -1087,7 +1624,31 @@@ void ff_get_unscaled_swscale(SwsContex
      if (srcFormat == AV_PIX_FMT_GBRP && isPlanar(srcFormat) && isByteRGB(dstFormat))
          c->swscale = planarRgbToRgbWrapper;
  
-     if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth_minus1 == 7 &&
 +    if ((srcFormat == AV_PIX_FMT_RGB48LE  || srcFormat == AV_PIX_FMT_RGB48BE  ||
 +         srcFormat == AV_PIX_FMT_BGR48LE  || srcFormat == AV_PIX_FMT_BGR48BE  ||
 +         srcFormat == AV_PIX_FMT_RGBA64LE || srcFormat == AV_PIX_FMT_RGBA64BE ||
 +         srcFormat == AV_PIX_FMT_BGRA64LE || srcFormat == AV_PIX_FMT_BGRA64BE) &&
 +        (dstFormat == AV_PIX_FMT_GBRP9LE  || dstFormat == AV_PIX_FMT_GBRP9BE  ||
 +         dstFormat == AV_PIX_FMT_GBRP10LE || dstFormat == AV_PIX_FMT_GBRP10BE ||
 +         dstFormat == AV_PIX_FMT_GBRP12LE || dstFormat == AV_PIX_FMT_GBRP12BE ||
 +         dstFormat == AV_PIX_FMT_GBRP14LE || dstFormat == AV_PIX_FMT_GBRP14BE ||
 +         dstFormat == AV_PIX_FMT_GBRP16LE || dstFormat == AV_PIX_FMT_GBRP16BE ||
 +         dstFormat == AV_PIX_FMT_GBRAP16LE || dstFormat == AV_PIX_FMT_GBRAP16BE ))
 +        c->swscale = Rgb16ToPlanarRgb16Wrapper;
 +
 +    if ((srcFormat == AV_PIX_FMT_GBRP9LE  || srcFormat == AV_PIX_FMT_GBRP9BE  ||
 +         srcFormat == AV_PIX_FMT_GBRP16LE || srcFormat == AV_PIX_FMT_GBRP16BE ||
 +         srcFormat == AV_PIX_FMT_GBRP10LE || srcFormat == AV_PIX_FMT_GBRP10BE ||
 +         srcFormat == AV_PIX_FMT_GBRP12LE || srcFormat == AV_PIX_FMT_GBRP12BE ||
 +         srcFormat == AV_PIX_FMT_GBRP14LE || srcFormat == AV_PIX_FMT_GBRP14BE ||
 +         srcFormat == AV_PIX_FMT_GBRAP16LE || srcFormat == AV_PIX_FMT_GBRAP16BE) &&
 +        (dstFormat == AV_PIX_FMT_RGB48LE  || dstFormat == AV_PIX_FMT_RGB48BE  ||
 +         dstFormat == AV_PIX_FMT_BGR48LE  || dstFormat == AV_PIX_FMT_BGR48BE  ||
 +         dstFormat == AV_PIX_FMT_RGBA64LE || dstFormat == AV_PIX_FMT_RGBA64BE ||
 +         dstFormat == AV_PIX_FMT_BGRA64LE || dstFormat == AV_PIX_FMT_BGRA64BE))
 +        c->swscale = planarRgb16ToRgb16Wrapper;
 +
+     if (av_pix_fmt_desc_get(srcFormat)->comp[0].depth == 8 &&
          isPackedRGB(srcFormat) && dstFormat == AV_PIX_FMT_GBRP)
          c->swscale = rgbToPlanarRgbWrapper;
  
@@@ -1327,31 -1019,41 +1327,31 @@@ av_cold int sws_init_context(SwsContex
           (flags & SWS_FAST_BILINEAR)))
          c->chrSrcHSubSample = 1;
  
 -    // Note the -((-x)>>y) is so that we always round toward +inf.
 -    c->chrSrcW = -((-srcW) >> c->chrSrcHSubSample);
 -    c->chrSrcH = -((-srcH) >> c->chrSrcVSubSample);
 -    c->chrDstW = -((-dstW) >> c->chrDstHSubSample);
 -    c->chrDstH = -((-dstH) >> c->chrDstVSubSample);
 -
 -    /* unscaled special cases */
 -    if (unscaled && !usesHFilter && !usesVFilter &&
 -        (c->srcRange == c->dstRange || isAnyRGB(dstFormat))) {
 -        ff_get_unscaled_swscale(c);
 +    // Note the FF_CEIL_RSHIFT is so that we always round toward +inf.
 +    c->chrSrcW = FF_CEIL_RSHIFT(srcW, c->chrSrcHSubSample);
 +    c->chrSrcH = FF_CEIL_RSHIFT(srcH, c->chrSrcVSubSample);
 +    c->chrDstW = FF_CEIL_RSHIFT(dstW, c->chrDstHSubSample);
 +    c->chrDstH = FF_CEIL_RSHIFT(dstH, c->chrDstVSubSample);
  
 -        if (c->swscale) {
 -            if (flags & SWS_PRINT_INFO)
 -                av_log(c, AV_LOG_INFO,
 -                       "using unscaled %s -> %s special converter\n",
 -                       sws_format_name(srcFormat), sws_format_name(dstFormat));
 -            return 0;
 -        }
 -    }
 +    FF_ALLOCZ_OR_GOTO(c, c->formatConvBuffer, FFALIGN(srcW*2+78, 16) * 2, fail);
  
-     c->srcBpc = 1 + desc_src->comp[0].depth_minus1;
+     c->srcBpc = desc_src->comp[0].depth;
      if (c->srcBpc < 8)
          c->srcBpc = 8;
-     c->dstBpc = 1 + desc_dst->comp[0].depth_minus1;
+     c->dstBpc = desc_dst->comp[0].depth;
      if (c->dstBpc < 8)
          c->dstBpc = 8;
 +    if (isAnyRGB(srcFormat) || srcFormat == AV_PIX_FMT_PAL8)
 +        c->srcBpc = 16;
      if (c->dstBpc == 16)
          dst_stride <<= 1;
 -    FF_ALLOC_OR_GOTO(c, c->formatConvBuffer,
 -                     (FFALIGN(srcW, 16) * 2 * FFALIGN(c->srcBpc, 8) >> 3) + 16,
 -                     fail);
 -    if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 10) {
 -        c->canMMXEXTBeUsed = (dstW >= srcW && (dstW & 31) == 0 &&
 -                              (srcW & 15) == 0) ? 1 : 0;
 -        if (!c->canMMXEXTBeUsed && dstW >= srcW && (srcW & 15) == 0
 +
 +    if (INLINE_MMXEXT(cpu_flags) && c->srcBpc == 8 && c->dstBpc <= 14) {
 +        c->canMMXEXTBeUsed = dstW >= srcW && (dstW & 31) == 0 &&
 +                             c->chrDstW >= c->chrSrcW &&
 +                             (srcW & 15) == 0;
 +        if (!c->canMMXEXTBeUsed && dstW >= srcW && c->chrDstW >= c->chrSrcW && (srcW & 15) == 0
 +
              && (flags & SWS_FAST_BILINEAR)) {
              if (flags & SWS_PRINT_INFO)
                  av_log(c, AV_LOG_INFO,