doxygen/3.1/vf__hqx_8c_source.html

 /*

  * Copyright (c) 2014 Clément Bœsch

  *

  * This file is part of FFmpeg.

  *

  * Permission to use, copy, modify, and/or distribute this software for any

  * purpose with or without fee is hereby granted, provided that the above

  * copyright notice and this permission notice appear in all copies.

  *

  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

  */


 /**

  * @file

  * hqx magnification filters (hq2x, hq3x, hq4x)

  *

  * Originally designed by Maxim Stephin.

  *

  * @see http://en.wikipedia.org/wiki/Hqx

  * @see http://web.archive.org/web/20131114143602/http://www.hiend3d.com/hq3x.html

  * @see http://blog.pkh.me/p/19-butchering-hqx-scaling-filters.html

  */


 #include "libavutil/opt.h"

 #include "libavutil/avassert.h"

 #include "libavutil/pixdesc.h"

 #include "internal.h"


 typedef int (*hqxfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs);


 typedef struct {

     const AVClass *class;

     int n;

     hqxfunc_t func;

     uint32_t rgbtoyuv[1<<24];

 } HQXContext;


 typedef struct ThreadData {

     AVFrame *in, *out;

     const uint32_t *rgbtoyuv;

 } ThreadData;


 #define OFFSET(x) offsetof(HQXContext, x)

 #define FLAGS AV_OPT_FLAG_FILTERING_PARAM|AV_OPT_FLAG_VIDEO_PARAM

 static const AVOption hqx_options[] = {

     { "n", "set scale factor", OFFSET(n), AV_OPT_TYPE_INT, {.i64 = 3}, 2, 4, .flags = FLAGS },

     { NULL }

 };


 AVFILTER_DEFINE_CLASS(hqx);


 static av_always_inline uint32_t rgb2yuv(const uint32_t *r2y, uint32_t c)

 {

     return r2y[c & 0xffffff];

 }


 static av_always_inline int yuv_diff(uint32_t yuv1, uint32_t yuv2)

 {

 #define YMASK 0xff0000

 #define UMASK 0x00ff00

 #define VMASK 0x0000ff

 #define ABSDIFF(a,b) (abs((int)(a)-(int)(b)))


     return ABSDIFF(yuv1 & YMASK, yuv2 & YMASK) > (48 << 16) ||

            ABSDIFF(yuv1 & UMASK, yuv2 & UMASK) > ( 7 <<  8) ||

            ABSDIFF(yuv1 & VMASK, yuv2 & VMASK) > ( 6 <<  0);

 }


 /* (c1*w1 + c2*w2) >> s */

 static av_always_inline uint32_t interp_2px(uint32_t c1, int w1, uint32_t c2, int w2, int s)

 {

     return (((((c1 & 0xff00ff00) >> 8) * w1 + ((c2 & 0xff00ff00) >> 8) * w2) << (8 - s)) & 0xff00ff00) |

            (((((c1 & 0x00ff00ff)     ) * w1 + ((c2 & 0x00ff00ff)     ) * w2) >>      s ) & 0x00ff00ff);

 }


 /* (c1*w1 + c2*w2 + c3*w3) >> s */

 static av_always_inline uint32_t interp_3px(uint32_t c1, int w1, uint32_t c2, int w2, uint32_t c3, int w3, int s)

 {

     return (((((c1 & 0xff00ff00) >> 8) * w1 + ((c2 & 0xff00ff00) >> 8) * w2 + ((c3 & 0xff00ff00) >> 8) * w3) << (8 - s)) & 0xff00ff00) |

            (((((c1 & 0x00ff00ff)     ) * w1 + ((c2 & 0x00ff00ff)     ) * w2 + ((c3 & 0x00ff00ff)     ) * w3) >>      s ) & 0x00ff00ff);

 }


 /* m is the mask of diff with the center pixel that matters in the pattern, and

  * r is the expected result (bit set to 1 if there is difference with the

  * center, 0 otherwise) */

 #define P(m, r) ((k_shuffled & (m)) == (r))


 /* adjust 012345678 to 01235678: the mask doesn't contain the (null) diff

  * between the center/current pixel and itself */

 #define DROP4(z) ((z) > 4 ? (z)-1 : (z))


 /* shuffle the input mask: move bit n (4-adjusted) to position stored in p<n> */

 #define SHF(x, rot, n) (((x) >> ((rot) ? 7-DROP4(n) : DROP4(n)) & 1) << DROP4(p##n))


 /* used to check if there is YUV difference between 2 pixels */

 #define WDIFF(c1, c2) yuv_diff(rgb2yuv(r2y, c1), rgb2yuv(r2y, c2))


 /* bootstrap template for every interpolation code. It defines the shuffled

  * masks and surrounding pixels. The rot flag is used to indicate if it's a

  * rotation; its basic effect is to shuffle k using p8..p0 instead of p0..p8 */

 #define INTERP_BOOTSTRAP(rot)                                           \

     const int k_shuffled = SHF(k,rot,0) | SHF(k,rot,1) | SHF(k,rot,2)   \

                          | SHF(k,rot,3) |       0      | SHF(k,rot,5)   \

                          | SHF(k,rot,6) | SHF(k,rot,7) | SHF(k,rot,8);  \

                                                                         \

     const uint32_t w0 = w[p0], w1 = w[p1],                              \

                    w3 = w[p3], w4 = w[p4], w5 = w[p5],                  \

                                w7 = w[p7]


 /* Assuming p0..p8 is mapped to pixels 0..8, this function interpolates the

  * top-left pixel in the total of the 2x2 pixels to interpolates. The function

  * is also used for the 3 other pixels */

 static av_always_inline uint32_t hq2x_interp_1x1(const uint32_t *r2y, int k,

                                                  const uint32_t *w,

                                                  int p0, int p1, int p2,

                                                  int p3, int p4, int p5,

                                                  int p6, int p7, int p8)

 {

     INTERP_BOOTSTRAP(0);


     if ((P(0xbf,0x37) || P(0xdb,0x13)) && WDIFF(w1, w5))

         return interp_2px(w4, 3, w3, 1, 2);

     if ((P(0xdb,0x49) || P(0xef,0x6d)) && WDIFF(w7, w3))

         return interp_2px(w4, 3, w1, 1, 2);

     if ((P(0x0b,0x0b) || P(0xfe,0x4a) || P(0xfe,0x1a)) && WDIFF(w3, w1))

         return w4;

     if ((P(0x6f,0x2a) || P(0x5b,0x0a) || P(0xbf,0x3a) || P(0xdf,0x5a) ||

          P(0x9f,0x8a) || P(0xcf,0x8a) || P(0xef,0x4e) || P(0x3f,0x0e) ||

          P(0xfb,0x5a) || P(0xbb,0x8a) || P(0x7f,0x5a) || P(0xaf,0x8a) ||

          P(0xeb,0x8a)) && WDIFF(w3, w1))

         return interp_2px(w4, 3, w0, 1, 2);

     if (P(0x0b,0x08))

         return interp_3px(w4, 2, w0, 1, w1, 1, 2);

     if (P(0x0b,0x02))

         return interp_3px(w4, 2, w0, 1, w3, 1, 2);

     if (P(0x2f,0x2f))

         return interp_3px(w4, 14, w3, 1, w1, 1, 4);

     if (P(0xbf,0x37) || P(0xdb,0x13))

         return interp_3px(w4, 5, w1, 2, w3, 1, 3);

     if (P(0xdb,0x49) || P(0xef,0x6d))

         return interp_3px(w4, 5, w3, 2, w1, 1, 3);

     if (P(0x1b,0x03) || P(0x4f,0x43) || P(0x8b,0x83) || P(0x6b,0x43))

         return interp_2px(w4, 3, w3, 1, 2);

     if (P(0x4b,0x09) || P(0x8b,0x89) || P(0x1f,0x19) || P(0x3b,0x19))

         return interp_2px(w4, 3, w1, 1, 2);

     if (P(0x7e,0x2a) || P(0xef,0xab) || P(0xbf,0x8f) || P(0x7e,0x0e))

         return interp_3px(w4, 2, w3, 3, w1, 3, 3);

     if (P(0xfb,0x6a) || P(0x6f,0x6e) || P(0x3f,0x3e) || P(0xfb,0xfa) ||

         P(0xdf,0xde) || P(0xdf,0x1e))

         return interp_2px(w4, 3, w0, 1, 2);

     if (P(0x0a,0x00) || P(0x4f,0x4b) || P(0x9f,0x1b) || P(0x2f,0x0b) ||

         P(0xbe,0x0a) || P(0xee,0x0a) || P(0x7e,0x0a) || P(0xeb,0x4b) ||

         P(0x3b,0x1b))

         return interp_3px(w4, 2, w3, 1, w1, 1, 2);

     return interp_3px(w4, 6, w3, 1, w1, 1, 3);

 }


 /* Assuming p0..p8 is mapped to pixels 0..8, this function interpolates the

  * top-left and top-center pixel in the total of the 3x3 pixels to

  * interpolates. The function is also used for the 3 other couples of pixels

  * defining the outline. The center pixel is not defined through this function,

  * since it's just the same as the original value. */

 static av_always_inline void hq3x_interp_2x1(uint32_t *dst, int dst_linesize,

                                              const uint32_t *r2y, int k,

                                              const uint32_t *w,

                                              int pos00, int pos01,

                                              int p0, int p1, int p2,

                                              int p3, int p4, int p5,

                                              int p6, int p7, int p8,

                                              int rotate)

 {

     INTERP_BOOTSTRAP(rotate);


     uint32_t *dst00 = &dst[dst_linesize*(pos00>>1) + (pos00&1)];

     uint32_t *dst01 = &dst[dst_linesize*(pos01>>1) + (pos01&1)];


     if ((P(0xdb,0x49) || P(0xef,0x6d)) && WDIFF(w7, w3))

         *dst00 = interp_2px(w4, 3, w1, 1, 2);

     else if ((P(0xbf,0x37) || P(0xdb,0x13)) && WDIFF(w1, w5))

         *dst00 = interp_2px(w4, 3, w3, 1, 2);

     else if ((P(0x0b,0x0b) || P(0xfe,0x4a) || P(0xfe,0x1a)) && WDIFF(w3, w1))

         *dst00 = w4;

     else if ((P(0x6f,0x2a) || P(0x5b,0x0a) || P(0xbf,0x3a) || P(0xdf,0x5a) ||

               P(0x9f,0x8a) || P(0xcf,0x8a) || P(0xef,0x4e) || P(0x3f,0x0e) ||

               P(0xfb,0x5a) || P(0xbb,0x8a) || P(0x7f,0x5a) || P(0xaf,0x8a) ||

               P(0xeb,0x8a)) && WDIFF(w3, w1))

         *dst00 = interp_2px(w4, 3, w0, 1, 2);

     else if (P(0x4b,0x09) || P(0x8b,0x89) || P(0x1f,0x19) || P(0x3b,0x19))

         *dst00 = interp_2px(w4, 3, w1, 1, 2);

     else if (P(0x1b,0x03) || P(0x4f,0x43) || P(0x8b,0x83) || P(0x6b,0x43))

         *dst00 = interp_2px(w4, 3, w3, 1, 2);

     else if (P(0x7e,0x2a) || P(0xef,0xab) || P(0xbf,0x8f) || P(0x7e,0x0e))

         *dst00 = interp_2px(w3, 1, w1, 1, 1);

     else if (P(0x4f,0x4b) || P(0x9f,0x1b) || P(0x2f,0x0b) || P(0xbe,0x0a) ||

              P(0xee,0x0a) || P(0x7e,0x0a) || P(0xeb,0x4b) || P(0x3b,0x1b))

         *dst00 = interp_3px(w4, 2, w3, 7, w1, 7, 4);

     else if (P(0x0b,0x08) || P(0xf9,0x68) || P(0xf3,0x62) || P(0x6d,0x6c) ||

              P(0x67,0x66) || P(0x3d,0x3c) || P(0x37,0x36) || P(0xf9,0xf8) ||

              P(0xdd,0xdc) || P(0xf3,0xf2) || P(0xd7,0xd6) || P(0xdd,0x1c) ||

              P(0xd7,0x16) || P(0x0b,0x02))

         *dst00 = interp_2px(w4, 3, w0, 1, 2);

     else

         *dst00 = interp_3px(w4, 2, w3, 1, w1, 1, 2);


     if ((P(0xfe,0xde) || P(0x9e,0x16) || P(0xda,0x12) || P(0x17,0x16) ||

          P(0x5b,0x12) || P(0xbb,0x12)) && WDIFF(w1, w5))

         *dst01 = w4;

     else if ((P(0x0f,0x0b) || P(0x5e,0x0a) || P(0xfb,0x7b) || P(0x3b,0x0b) ||

               P(0xbe,0x0a) || P(0x7a,0x0a)) && WDIFF(w3, w1))

         *dst01 = w4;

     else if (P(0xbf,0x8f) || P(0x7e,0x0e) || P(0xbf,0x37) || P(0xdb,0x13))

         *dst01 = interp_2px(w1, 3, w4, 1, 2);

     else if (P(0x02,0x00) || P(0x7c,0x28) || P(0xed,0xa9) || P(0xf5,0xb4) ||

              P(0xd9,0x90))

         *dst01 = interp_2px(w4, 3, w1, 1, 2);

     else if (P(0x4f,0x4b) || P(0xfb,0x7b) || P(0xfe,0x7e) || P(0x9f,0x1b) ||

              P(0x2f,0x0b) || P(0xbe,0x0a) || P(0x7e,0x0a) || P(0xfb,0x4b) ||

              P(0xfb,0xdb) || P(0xfe,0xde) || P(0xfe,0x56) || P(0x57,0x56) ||

              P(0x97,0x16) || P(0x3f,0x1e) || P(0xdb,0x12) || P(0xbb,0x12))

         *dst01 = interp_2px(w4, 7, w1, 1, 3);

     else

         *dst01 = w4;

 }


 /* Assuming p0..p8 is mapped to pixels 0..8, this function interpolates the

  * top-left block of 2x2 pixels in the total of the 4x4 pixels (or 4 blocks) to

  * interpolates. The function is also used for the 3 other blocks of 2x2

  * pixels. */

 static av_always_inline void hq4x_interp_2x2(uint32_t *dst, int dst_linesize,

                                              const uint32_t *r2y, int k,

                                              const uint32_t *w,

                                              int pos00, int pos01,

                                              int pos10, int pos11,

                                              int p0, int p1, int p2,

                                              int p3, int p4, int p5,

                                              int p6, int p7, int p8)

 {

     INTERP_BOOTSTRAP(0);


     uint32_t *dst00 = &dst[dst_linesize*(pos00>>1) + (pos00&1)];

     uint32_t *dst01 = &dst[dst_linesize*(pos01>>1) + (pos01&1)];

     uint32_t *dst10 = &dst[dst_linesize*(pos10>>1) + (pos10&1)];

     uint32_t *dst11 = &dst[dst_linesize*(pos11>>1) + (pos11&1)];


     const int cond00 = (P(0xbf,0x37) || P(0xdb,0x13)) && WDIFF(w1, w5);

     const int cond01 = (P(0xdb,0x49) || P(0xef,0x6d)) && WDIFF(w7, w3);

     const int cond02 = (P(0x6f,0x2a) || P(0x5b,0x0a) || P(0xbf,0x3a) ||

                         P(0xdf,0x5a) || P(0x9f,0x8a) || P(0xcf,0x8a) ||

                         P(0xef,0x4e) || P(0x3f,0x0e) || P(0xfb,0x5a) ||

                         P(0xbb,0x8a) || P(0x7f,0x5a) || P(0xaf,0x8a) ||

                         P(0xeb,0x8a)) && WDIFF(w3, w1);

     const int cond03 = P(0xdb,0x49) || P(0xef,0x6d);

     const int cond04 = P(0xbf,0x37) || P(0xdb,0x13);

     const int cond05 = P(0x1b,0x03) || P(0x4f,0x43) || P(0x8b,0x83) ||

                        P(0x6b,0x43);

     const int cond06 = P(0x4b,0x09) || P(0x8b,0x89) || P(0x1f,0x19) ||

                        P(0x3b,0x19);

     const int cond07 = P(0x0b,0x08) || P(0xf9,0x68) || P(0xf3,0x62) ||

                        P(0x6d,0x6c) || P(0x67,0x66) || P(0x3d,0x3c) ||

                        P(0x37,0x36) || P(0xf9,0xf8) || P(0xdd,0xdc) ||

                        P(0xf3,0xf2) || P(0xd7,0xd6) || P(0xdd,0x1c) ||

                        P(0xd7,0x16) || P(0x0b,0x02);

     const int cond08 = (P(0x0f,0x0b) || P(0x2b,0x0b) || P(0xfe,0x4a) ||

                         P(0xfe,0x1a)) && WDIFF(w3, w1);

     const int cond09 = P(0x2f,0x2f);

     const int cond10 = P(0x0a,0x00);

     const int cond11 = P(0x0b,0x09);

     const int cond12 = P(0x7e,0x2a) || P(0xef,0xab);

     const int cond13 = P(0xbf,0x8f) || P(0x7e,0x0e);

     const int cond14 = P(0x4f,0x4b) || P(0x9f,0x1b) || P(0x2f,0x0b) ||

                        P(0xbe,0x0a) || P(0xee,0x0a) || P(0x7e,0x0a) ||

                        P(0xeb,0x4b) || P(0x3b,0x1b);

     const int cond15 = P(0x0b,0x03);


     if (cond00)

         *dst00 = interp_2px(w4, 5, w3, 3, 3);

     else if (cond01)

         *dst00 = interp_2px(w4, 5, w1, 3, 3);

     else if ((P(0x0b,0x0b) || P(0xfe,0x4a) || P(0xfe,0x1a)) && WDIFF(w3, w1))

         *dst00 = w4;

     else if (cond02)

         *dst00 = interp_2px(w4, 5, w0, 3, 3);

     else if (cond03)

         *dst00 = interp_2px(w4, 3, w3, 1, 2);

     else if (cond04)

         *dst00 = interp_2px(w4, 3, w1, 1, 2);

     else if (cond05)

         *dst00 = interp_2px(w4, 5, w3, 3, 3);

     else if (cond06)

         *dst00 = interp_2px(w4, 5, w1, 3, 3);

     else if (P(0x0f,0x0b) || P(0x5e,0x0a) || P(0x2b,0x0b) || P(0xbe,0x0a) ||

              P(0x7a,0x0a) || P(0xee,0x0a))

         *dst00 = interp_2px(w1, 1, w3, 1, 1);

     else if (cond07)

         *dst00 = interp_2px(w4, 5, w0, 3, 3);

     else

         *dst00 = interp_3px(w4, 2, w1, 1, w3, 1, 2);


     if (cond00)

         *dst01 = interp_2px(w4, 7, w3, 1, 3);

     else if (cond08)

         *dst01 = w4;

     else if (cond02)

         *dst01 = interp_2px(w4, 3, w0, 1, 2);

     else if (cond09)

         *dst01 = w4;

     else if (cond10)

         *dst01 = interp_3px(w4, 5, w1, 2, w3, 1, 3);

     else if (P(0x0b,0x08))

         *dst01 = interp_3px(w4, 5, w1, 2, w0, 1, 3);

     else if (cond11)

         *dst01 = interp_2px(w4, 5, w1, 3, 3);

     else if (cond04)

         *dst01 = interp_2px(w1, 3, w4, 1, 2);

     else if (cond12)

         *dst01 = interp_3px(w1, 2, w4, 1, w3, 1, 2);

     else if (cond13)

         *dst01 = interp_2px(w1, 5, w3, 3, 3);

     else if (cond05)

         *dst01 = interp_2px(w4, 7, w3, 1, 3);

     else if (P(0xf3,0x62) || P(0x67,0x66) || P(0x37,0x36) || P(0xf3,0xf2) ||

              P(0xd7,0xd6) || P(0xd7,0x16) || P(0x0b,0x02))

         *dst01 = interp_2px(w4, 3, w0, 1, 2);

     else if (cond14)

         *dst01 = interp_2px(w1, 1, w4, 1, 1);

     else

         *dst01 = interp_2px(w4, 3, w1, 1, 2);


     if (cond01)

         *dst10 = interp_2px(w4, 7, w1, 1, 3);

     else if (cond08)

         *dst10 = w4;

     else if (cond02)

         *dst10 = interp_2px(w4, 3, w0, 1, 2);

     else if (cond09)

         *dst10 = w4;

     else if (cond10)

         *dst10 = interp_3px(w4, 5, w3, 2, w1, 1, 3);

     else if (P(0x0b,0x02))

         *dst10 = interp_3px(w4, 5, w3, 2, w0, 1, 3);

     else if (cond15)

         *dst10 = interp_2px(w4, 5, w3, 3, 3);

     else if (cond03)

         *dst10 = interp_2px(w3, 3, w4, 1, 2);

     else if (cond13)

         *dst10 = interp_3px(w3, 2, w4, 1, w1, 1, 2);

     else if (cond12)

         *dst10 = interp_2px(w3, 5, w1, 3, 3);

     else if (cond06)

         *dst10 = interp_2px(w4, 7, w1, 1, 3);

     else if (P(0x0b,0x08) || P(0xf9,0x68) || P(0x6d,0x6c) || P(0x3d,0x3c) ||

              P(0xf9,0xf8) || P(0xdd,0xdc) || P(0xdd,0x1c))

         *dst10 = interp_2px(w4, 3, w0, 1, 2);

     else if (cond14)

         *dst10 = interp_2px(w3, 1, w4, 1, 1);

     else

         *dst10 = interp_2px(w4, 3, w3, 1, 2);


     if ((P(0x7f,0x2b) || P(0xef,0xab) || P(0xbf,0x8f) || P(0x7f,0x0f)) &&

          WDIFF(w3, w1))

         *dst11 = w4;

     else if (cond02)

         *dst11 = interp_2px(w4, 7, w0, 1, 3);

     else if (cond15)

         *dst11 = interp_2px(w4, 7, w3, 1, 3);

     else if (cond11)

         *dst11 = interp_2px(w4, 7, w1, 1, 3);

     else if (P(0x0a,0x00) || P(0x7e,0x2a) || P(0xef,0xab) || P(0xbf,0x8f) ||

              P(0x7e,0x0e))

         *dst11 = interp_3px(w4, 6, w3, 1, w1, 1, 3);

     else if (cond07)

         *dst11 = interp_2px(w4, 7, w0, 1, 3);

     else

         *dst11 = w4;

 }


 static av_always_inline void hqx_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)

 {

     int x, y;

     AVFrame *in = td->in, *out = td->out;

     const uint32_t *r2y = td->rgbtoyuv;

     const int height = in->height;

     const int width  = in->width;

     const int slice_start = (height *  jobnr   ) / nb_jobs;

     const int slice_end   = (height * (jobnr+1)) / nb_jobs;

     const int dst_linesize = out->linesize[0];

     const int src_linesize =  in->linesize[0];

     uint8_t       *dst = out->data[0] + slice_start * dst_linesize * n;

     const uint8_t *src =  in->data[0] + slice_start * src_linesize;


     const int dst32_linesize = dst_linesize >> 2;

     const int src32_linesize = src_linesize >> 2;


     for (y = slice_start; y < slice_end; y++) {

         const uint32_t *src32 = (const uint32_t *)src;

         uint32_t       *dst32 = (uint32_t *)dst;

         const int prevline = y > 0          ? -src32_linesize : 0;

         const int nextline = y < height - 1 ?  src32_linesize : 0;


         for (x = 0; x < width; x++) {

             const int prevcol = x > 0        ? -1 : 0;

             const int nextcol = x < width -1 ?  1 : 0;

             const uint32_t w[3*3] = {

                 src32[prevcol + prevline], src32[prevline], src32[prevline + nextcol],

                 src32[prevcol           ], src32[       0], src32[           nextcol],

                 src32[prevcol + nextline], src32[nextline], src32[nextline + nextcol]

             };

             const uint32_t yuv1 = rgb2yuv(r2y, w[4]);

             const int pattern = (w[4] != w[0] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[0]))) : 0)

                               | (w[4] != w[1] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[1]))) : 0) << 1

                               | (w[4] != w[2] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[2]))) : 0) << 2

                               | (w[4] != w[3] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[3]))) : 0) << 3

                               | (w[4] != w[5] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[5]))) : 0) << 4

                               | (w[4] != w[6] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[6]))) : 0) << 5

                               | (w[4] != w[7] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[7]))) : 0) << 6

                               | (w[4] != w[8] ? (yuv_diff(yuv1, rgb2yuv(r2y, w[8]))) : 0) << 7;


             if (n == 2) {

                 dst32[dst32_linesize*0 + 0] = hq2x_interp_1x1(r2y, pattern, w, 0,1,2,3,4,5,6,7,8);  // 00

                 dst32[dst32_linesize*0 + 1] = hq2x_interp_1x1(r2y, pattern, w, 2,1,0,5,4,3,8,7,6);  // 01 (vert mirrored)

                 dst32[dst32_linesize*1 + 0] = hq2x_interp_1x1(r2y, pattern, w, 6,7,8,3,4,5,0,1,2);  // 10 (horiz mirrored)

                 dst32[dst32_linesize*1 + 1] = hq2x_interp_1x1(r2y, pattern, w, 8,7,6,5,4,3,2,1,0);  // 11 (center mirrored)

             } else if (n == 3) {

                 hq3x_interp_2x1(dst32,                        dst32_linesize, r2y, pattern, w, 0,1, 0,1,2,3,4,5,6,7,8, 0);  // 00 01

                 hq3x_interp_2x1(dst32 + 1,                    dst32_linesize, r2y, pattern, w, 1,3, 2,5,8,1,4,7,0,3,6, 1);  // 02 12 (rotated to the right)

                 hq3x_interp_2x1(dst32 + 1*dst32_linesize,     dst32_linesize, r2y, pattern, w, 2,0, 6,3,0,7,4,1,8,5,2, 1);  // 20 10 (rotated to the left)

                 hq3x_interp_2x1(dst32 + 1*dst32_linesize + 1, dst32_linesize, r2y, pattern, w, 3,2, 8,7,6,5,4,3,2,1,0, 0);  // 22 21 (center mirrored)

                 dst32[dst32_linesize + 1] = w[4];                                                                           // 11

             } else if (n == 4) {

                 hq4x_interp_2x2(dst32,                        dst32_linesize, r2y, pattern, w, 0,1,2,3, 0,1,2,3,4,5,6,7,8); // 00 01 10 11

                 hq4x_interp_2x2(dst32 + 2,                    dst32_linesize, r2y, pattern, w, 1,0,3,2, 2,1,0,5,4,3,8,7,6); // 02 03 12 13 (vert mirrored)

                 hq4x_interp_2x2(dst32 + 2*dst32_linesize,     dst32_linesize, r2y, pattern, w, 2,3,0,1, 6,7,8,3,4,5,0,1,2); // 20 21 30 31 (horiz mirrored)

                 hq4x_interp_2x2(dst32 + 2*dst32_linesize + 2, dst32_linesize, r2y, pattern, w, 3,2,1,0, 8,7,6,5,4,3,2,1,0); // 22 23 32 33 (center mirrored)

             } else {

                 av_assert0(0);

             }


             src32 += 1;

             dst32 += n;

         }


         src += src_linesize;

         dst += dst_linesize * n;

     }

 }


 #define HQX_FUNC(size) \

 static int hq##size##x(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs) \

 { \

     hqx_filter(arg, jobnr, nb_jobs, size); \

     return 0; \

 }


 HQX_FUNC(2)

 HQX_FUNC(3)

 HQX_FUNC(4)


 static int query_formats(AVFilterContext *ctx)

 {

     static const enum AVPixelFormat pix_fmts[] = {AV_PIX_FMT_RGB32, AV_PIX_FMT_NONE};

     AVFilterFormats *fmts_list = ff_make_format_list(pix_fmts);

     if (!fmts_list)

         return AVERROR(ENOMEM);

     return ff_set_common_formats(ctx, fmts_list);

 }


 static int config_output(AVFilterLink *outlink)

 {

     AVFilterContext *ctx = outlink->src;

     HQXContext *hqx = ctx->priv;

     AVFilterLink *inlink = ctx->inputs[0];


     outlink->w = inlink->w * hqx->n;

     outlink->h = inlink->h * hqx->n;

     av_log(inlink->dst, AV_LOG_VERBOSE, "fmt:%s size:%dx%d -> size:%dx%d\n",

            av_get_pix_fmt_name(inlink->format),

            inlink->w, inlink->h, outlink->w, outlink->h);

     return 0;

 }


 static int filter_frame(AVFilterLink *inlink, AVFrame *in)

 {

     AVFilterContext *ctx = inlink->dst;

     AVFilterLink *outlink = ctx->outputs[0];

     HQXContext *hqx = ctx->priv;

     ThreadData td;

     AVFrame *out = ff_get_video_buffer(outlink, outlink->w, outlink->h);

     if (!out) {

         av_frame_free(&in);

         return AVERROR(ENOMEM);

     }

     av_frame_copy_props(out, in);

     out->width  = outlink->w;

     out->height = outlink->h;


     td.in = in;

     td.out = out;

     td.rgbtoyuv = hqx->rgbtoyuv;

     ctx->internal->execute(ctx, hqx->func, &td, NULL, FFMIN(inlink->h, ctx->graph->nb_threads));


     av_frame_free(&in);

     return ff_filter_frame(outlink, out);

 }


 static av_cold int init(AVFilterContext *ctx)

 {

     HQXContext *hqx = ctx->priv;

     static const hqxfunc_t hqxfuncs[] = {hq2x, hq3x, hq4x};


     uint32_t c;

     int bg, rg, g;


     for (bg=-255; bg<256; bg++) {

         for (rg=-255; rg<256; rg++) {

             const uint32_t u = (uint32_t)((-169*rg + 500*bg)/1000) + 128;

             const uint32_t v = (uint32_t)(( 500*rg -  81*bg)/1000) + 128;

             int startg = FFMAX3(-bg, -rg, 0);

             int endg = FFMIN3(255-bg, 255-rg, 255);

             uint32_t y = (uint32_t)(( 299*rg + 1000*startg + 114*bg)/1000);

             c = bg + (rg<<16) + 0x010101 * startg;

             for (g = startg; g <= endg; g++) {

                 hqx->rgbtoyuv[c] = ((y++) << 16) + (u << 8) + v;

                 c+= 0x010101;

             }

         }

     }


     hqx->func = hqxfuncs[hqx->n - 2];

     return 0;

 }


 static const AVFilterPad hqx_inputs[] = {

     {

         .name         = "default",

         .type         = AVMEDIA_TYPE_VIDEO,

         .filter_frame = filter_frame,

     },

     { NULL }

 };


 static const AVFilterPad hqx_outputs[] = {

     {

         .name         = "default",

         .type         = AVMEDIA_TYPE_VIDEO,

         .config_props = config_output,

     },

     { NULL }

 };


 AVFilter ff_vf_hqx = {

     .name          = "hqx",

     .description   = NULL_IF_CONFIG_SMALL("Scale the input by 2, 3 or 4 using the hq*x magnification algorithm."),

     .priv_size     = sizeof(HQXContext),

     .init          = init,

     .query_formats = query_formats,

     .inputs        = hqx_inputs,

     .outputs       = hqx_outputs,

     .priv_class    = &hqx_class,

     .flags         = AVFILTER_FLAG_SLICE_THREADS,

 };

P
#define P(m, r)
Definition: vf_hqx.c:92

filter_frame
static int filter_frame(AVFilterLink *inlink, AVFrame *in)
Definition: vf_hqx.c:487

NULL
#define NULL
Definition: coverity.c:32

s
const char * s
Definition: avisynth_c.h:631

ThreadData::out
AVFrame * out
Definition: af_sofalizer.c:585

AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:184

AV_PIX_FMT_NONE
Definition: pixfmt.h:61

AVOption
AVOption.
Definition: opt.h:245

interp_3px
static av_always_inline uint32_t interp_3px(uint32_t c1, int w1, uint32_t c2, int w2, uint32_t c3, int w3, int s)
Definition: vf_hqx.c:83

UMASK
#define UMASK

g
const char * g
Definition: vf_curves.c:108

AV_OPT_TYPE_INT
Definition: opt.h:223

AVFilterLink::h
int h
agreed upon image height
Definition: avfilter.h:382

ABSDIFF
#define ABSDIFF(a, b)

HQXContext::n
int n
Definition: vf_hqx.c:39

ff_get_video_buffer
AVFrame * ff_get_video_buffer(AVFilterLink *link, int w, int h)
Request a picture buffer with a specific set of permissions.
Definition: video.c:76

WDIFF
#define WDIFF(c1, c2)
Definition: vf_hqx.c:102

ff_make_format_list
AVFilterFormats * ff_make_format_list(const int *fmts)
Create a list of supported formats.
Definition: formats.c:283

AVFilterContext::graph
struct AVFilterGraph * graph
filtergraph this filter belongs to
Definition: avfilter.h:322

AVFilterPad::name
const char * name
Pad name.
Definition: internal.h:59

init
static av_cold int init(AVFilterContext *ctx)
Definition: vf_hqx.c:511

AVFilterContext::inputs
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:313

av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37

ff_filter_frame
int ff_filter_frame(AVFilterLink *link, AVFrame *frame)
Send a frame of data to the next filter.
Definition: avfilter.c:1180

ThreadData::in
AVFrame * in
Definition: af_sofalizer.c:585

uint8_t
uint8_t
Definition: audio_convert.c:194

av_cold
#define av_cold
Definition: attributes.h:82

ff_vf_hqx
AVFilter ff_vf_hqx
Definition: vf_hqx.c:556

opt.h
AVOptions.

hq3x_interp_2x1
static av_always_inline void hq3x_interp_2x1(uint32_t *dst, int dst_linesize, const uint32_t *r2y, int k, const uint32_t *w, int pos00, int pos01, int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8, int rotate)
Definition: vf_hqx.c:169

HQXContext::func
hqxfunc_t func
Definition: vf_hqx.c:40

height
#define height

AVFilterGraph::nb_threads
int nb_threads
Maximum number of threads used by filters in this graph.
Definition: avfilter.h:804

FFMIN3
#define FFMIN3(a, b, c)
Definition: common.h:97

c1
static const uint64_t c1
Definition: murmur3.c:49

AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192

VMASK
#define VMASK

av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28

AVFilterPad
A filter pad used for either input or output.
Definition: internal.h:53

AVFilterLink
A link between two filters.
Definition: avfilter.h:371

yuv_diff
static av_always_inline int yuv_diff(uint32_t yuv1, uint32_t yuv2)
Definition: vf_hqx.c:63

AVFrame::width
int width
width and height of the video frame
Definition: frame.h:236

ff_set_common_formats
int ff_set_common_formats(AVFilterContext *ctx, AVFilterFormats *formats)
A helper for query_formats() which sets all links to the same list of formats.
Definition: formats.c:568

td
#define td
Definition: regdef.h:70

query_formats
static int query_formats(AVFilterContext *ctx)
Definition: vf_hqx.c:464

AVERROR
#define AVERROR(e)
Definition: error.h:43

av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:153

NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification. ...
Definition: internal.h:176

AVFilterContext::priv
void * priv
private data for use by the filter
Definition: avfilter.h:320

AVFILTER_FLAG_SLICE_THREADS
#define AVFILTER_FLAG_SLICE_THREADS
The filter supports multithreading by splitting frames into multiple parts and processing them concur...
Definition: avfilter.h:114

arg
const char * arg
Definition: jacosubdec.c:66

avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().

hqx_filter
static av_always_inline void hqx_filter(const ThreadData *td, int jobnr, int nb_jobs, int n)
Definition: vf_hqx.c:383

HQXContext
Definition: hqx.h:62

AVFilterLink::w
int w
agreed upon image width
Definition: avfilter.h:381

pixdesc.h

FFMIN
#define FFMIN(a, b)
Definition: common.h:96

width
#define width

AVFILTER_DEFINE_CLASS
AVFILTER_DEFINE_CLASS(hqx)

ctx
AVFormatContext * ctx
Definition: movenc.c:48

hqx_outputs
static const AVFilterPad hqx_outputs[]
Definition: vf_hqx.c:547

n
int n
Definition: avisynth_c.h:547

hqx_inputs
static const AVFilterPad hqx_inputs[]
Definition: vf_hqx.c:538

AVFilterLink::src
AVFilterContext * src
source filter
Definition: avfilter.h:372

interp_2px
static av_always_inline uint32_t interp_2px(uint32_t c1, int w1, uint32_t c2, int w2, int s)
Definition: vf_hqx.c:76

outputs
static const AVFilterPad outputs[]
Definition: af_afftfilt.c:386

config_output
static int config_output(AVFilterLink *outlink)
Definition: vf_hqx.c:473

src
#define src
Definition: vp9dsp.c:530

INTERP_BOOTSTRAP
#define INTERP_BOOTSTRAP(rot)
Definition: vf_hqx.c:107

AVFilterLink::format
int format
agreed upon media format
Definition: avfilter.h:388

OFFSET
#define OFFSET(x)
Definition: vf_hqx.c:49

HQX_FUNC
#define HQX_FUNC(size)
Definition: vf_hqx.c:453

hq4x_interp_2x2
static av_always_inline void hq4x_interp_2x2(uint32_t *dst, int dst_linesize, const uint32_t *r2y, int k, const uint32_t *w, int pos00, int pos01, int pos10, int pos11, int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8)
Definition: vf_hqx.c:235

inputs
static const AVFilterPad inputs[]
Definition: af_afftfilt.c:376

ThreadData
Definition: af_sofalizer.c:584

AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:215

AV_PIX_FMT_RGB32
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:318

ThreadData::rgbtoyuv
const uint32_t * rgbtoyuv
Definition: vf_hqx.c:46

in
uint8_t pi<< 24) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0f/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8, uint8_t,(*(constuint8_t *) pi-0x80)*(1.0/(1<< 7))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16, int16_t,(*(constint16_t *) pi >>8)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, int16_t,*(constint16_t *) pi *(1.0/(1<< 15))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32, int32_t,(*(constint32_t *) pi >>24)+0x80) CONV_FUNC_GROUP(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, int32_t,*(constint32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, float, av_clip_uint8(lrintf(*(constfloat *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, float, av_clip_int16(lrintf(*(constfloat *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, float, av_clipl_int32(llrintf(*(constfloat *) pi *(1U<< 31)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, double, av_clip_uint8(lrint(*(constdouble *) pi *(1<< 7))+0x80)) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, double, av_clip_int16(lrint(*(constdouble *) pi *(1<< 15)))) CONV_FUNC_GROUP(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, double, av_clipl_int32(llrint(*(constdouble *) pi *(1U<< 31))))#defineSET_CONV_FUNC_GROUP(ofmt, ifmt) staticvoidset_generic_function(AudioConvert *ac){}voidff_audio_convert_free(AudioConvert **ac){if(!*ac) return;ff_dither_free(&(*ac) ->dc);av_freep(ac);}AudioConvert *ff_audio_convert_alloc(AVAudioResampleContext *avr, enumAVSampleFormatout_fmt, enumAVSampleFormatin_fmt, intchannels, intsample_rate, intapply_map){AudioConvert *ac;intin_planar, out_planar;ac=av_mallocz(sizeof(*ac));if(!ac) returnNULL;ac->avr=avr;ac->out_fmt=out_fmt;ac->in_fmt=in_fmt;ac->channels=channels;ac->apply_map=apply_map;if(avr->dither_method!=AV_RESAMPLE_DITHER_NONE &&av_get_packed_sample_fmt(out_fmt)==AV_SAMPLE_FMT_S16 &&av_get_bytes_per_sample(in_fmt)>2){ac->dc=ff_dither_alloc(avr, out_fmt, in_fmt, channels, sample_rate, apply_map);if(!ac->dc){av_free(ac);returnNULL;}returnac;}in_planar=ff_sample_fmt_is_planar(in_fmt, channels);out_planar=ff_sample_fmt_is_planar(out_fmt, channels);if(in_planar==out_planar){ac->func_type=CONV_FUNC_TYPE_FLAT;ac->planes=in_planar?ac->channels:1;}elseif(in_planar) ac->func_type=CONV_FUNC_TYPE_INTERLEAVE;elseac->func_type=CONV_FUNC_TYPE_DEINTERLEAVE;set_generic_function(ac);if(ARCH_AARCH64) ff_audio_convert_init_aarch64(ac);if(ARCH_ARM) ff_audio_convert_init_arm(ac);if(ARCH_X86) ff_audio_convert_init_x86(ac);returnac;}intff_audio_convert(AudioConvert *ac, AudioData *out, AudioData *in){intuse_generic=1;intlen=in->nb_samples;intp;if(ac->dc){av_log(ac->avr, AV_LOG_TRACE,"%dsamples-audio_convert:%sto%s(dithered)\n", len, av_get_sample_fmt_name(ac->in_fmt), av_get_sample_fmt_name(ac->out_fmt));returnff_convert_dither(ac-> in
Definition: audio_convert.c:194

AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67

AVFilter
Filter definition.
Definition: avfilter.h:142

AVFilter::name
const char * name
Filter name.
Definition: avfilter.h:146

u
#define u(width,...)
Definition: vaapi_encode_h26x.h:36

AVFilterContext::outputs
AVFilterLink ** outputs
array of pointers to output links
Definition: avfilter.h:317

pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:262

YMASK
#define YMASK

AVFilterContext::internal
AVFilterInternal * internal
An opaque struct for libavfilter internal use.
Definition: avfilter.h:345

flags
static int flags
Definition: cpu.c:47

AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:198

c
static double c[64]
Definition: vsrc_mptestsrc.c:87

hqx_options
static const AVOption hqx_options[]
Definition: vf_hqx.c:51

c2
static const uint64_t c2
Definition: murmur3.c:50

AVFilterInternal::execute
avfilter_execute_func * execute
Definition: internal.h:153

slice_end
static int slice_end(AVCodecContext *avctx, AVFrame *pict)
Handle slice ends.
Definition: mpeg12dec.c:2051

hq2x_interp_1x1
static av_always_inline uint32_t hq2x_interp_1x1(const uint32_t *r2y, int k, const uint32_t *w, int p0, int p1, int p2, int p3, int p4, int p5, int p6, int p7, int p8)
Definition: vf_hqx.c:119

AVFilterLink::dst
AVFilterContext * dst
dest filter
Definition: avfilter.h:375

AVFilterFormats
A list of supported formats for one end of a filter link.
Definition: formats.h:64

AVFilterContext
An instance of a filter.
Definition: avfilter.h:305

AVFrame::height
int height
Definition: frame.h:236

out
FILE * out
Definition: movenc.c:54

AVMEDIA_TYPE_VIDEO
Definition: avutil.h:193

av_always_inline
#define av_always_inline
Definition: attributes.h:39

av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2138

internal.h
internal API functions

AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:60

rgb2yuv
static av_always_inline uint32_t rgb2yuv(const uint32_t *r2y, uint32_t c)
Definition: vf_hqx.c:58

HQXContext::rgbtoyuv
uint32_t rgbtoyuv[1<< 24]
Definition: vf_hqx.c:41

hqxfunc_t
int(* hqxfunc_t)(AVFilterContext *ctx, void *arg, int jobnr, int nb_jobs)
Definition: vf_hqx.c:35

av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:580

FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:95

FLAGS
#define FLAGS
Definition: vf_hqx.c:50