test/i965_jpeg_test_data.h

   1 /*
   2  * Copyright (C) 2016 Intel Corporation. All Rights Reserved.
   3  *
   4  * Permission is hereby granted, free of charge, to any person obtaining a
   5  * copy of this software and associated documentation files (the
   6  * "Software"), to deal in the Software without restriction, including
   7  * without limitation the rights to use, copy, modify, merge, publish,
   8  * distribute, sub license, and/or sell copies of the Software, and to
   9  * permit persons to whom the Software is furnished to do so, subject to
  10  * the following conditions:
  11  *
  12  * The above copyright notice and this permission notice (including the
  13  * next paragraph) shall be included in all copies or substantial portions
  14  * of the Software.
  15  *
  16  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
  17  * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  18  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.
  19  * IN NO EVENT SHALL PRECISION INSIGHT AND/OR ITS SUPPLIERS BE LIABLE FOR
  20  * ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  21  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  22  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  23  */
  24
  25 #ifndef I965_JPEG_TEST_DATA_H
  26 #define I965_JPEG_TEST_DATA_H
  27
  28 #include "i965_test_image_utils.h"
  29
  30 #include <array>
  31 #include <iostream>
  32 #include <map>
  33 #include <memory>
  34 #include <va/va.h>
  35 #include <vector>
  36
  37 namespace JPEG {
  38     typedef std::vector<uint8_t> ByteData;
  39
  40     static const VAProfile profile = VAProfileJPEGBaseline;
  41
  42     static inline const ByteData generateSolid(
  43         const std::array<uint8_t, 3>& yuv, const std::array<size_t, 2>& dim)
  44     {
  45         size_t count(dim[0] * dim[1]);
  46         ByteData data(count, yuv[0]);
  47         data.insert(data.end(), count, yuv[1]);
  48         data.insert(data.end(), count, yuv[2]);
  49         return data;
  50     }
  51 } // namespace JPEG
  52
  53 namespace JPEG {
  54 namespace Decode {
  55     typedef VAIQMatrixBufferJPEGBaseline                IQMatrix;
  56     typedef VAHuffmanTableBufferJPEGBaseline            HuffmanTable;
  57     typedef VAPictureParameterBufferJPEGBaseline        PictureParameter;
  58     typedef VASliceParameterBufferJPEGBaseline          SliceParameter;
  59
  60     static const VAEntrypoint entrypoint = VAEntrypointVLD;
  61
  62     static const HuffmanTable defaultHuffmanTable = {
  63         load_huffman_table: { 0x01, 0x01 },
  64         huffman_table: {
  65             { // luminance
  66                 num_dc_codes: {
  67                     0x00,0x01,0x05,0x01,0x01,0x01,0x01,0x01,0x01,0x00,0x00,0x00,
  68                     0x00,0x00,0x00,0x00
  69                 },
  70                 dc_values:    {
  71                     0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b
  72                 },
  73                 num_ac_codes: {
  74                     0x00,0x02,0x01,0x03,0x03,0x02,0x04,0x03,0x05,0x05,0x04,0x04,
  75                     0x00,0x00,0x01,0x7d
  76                 },
  77                 ac_values:    {
  78                     0x01,0x02,0x03,0x00,0x04,0x11,0x05,0x12,0x21,0x31,0x41,0x06,
  79                     0x13,0x51,0x61,0x07,0x22,0x71,0x14,0x32,0x81,0x91,0xa1,0x08,
  80                     0x23,0x42,0xb1,0xc1,0x15,0x52,0xd1,0xf0,0x24,0x33,0x62,0x72,
  81                     0x82,0x09,0x0a,0x16,0x17,0x18,0x19,0x1a,0x25,0x26,0x27,0x28,
  82                     0x29,0x2a,0x34,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,0x45,
  83                     0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,0x59,
  84                     0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,0x75,
  85                     0x76,0x77,0x78,0x79,0x7a,0x83,0x84,0x85,0x86,0x87,0x88,0x89,
  86                     0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,0xa2,0xa3,
  87                     0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,0xb5,0xb6,
  88                     0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,0xc8,0xc9,
  89                     0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,0xe1,0xe2,
  90                     0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf1,0xf2,0xf3,0xf4,
  91                     0xf5,0xf6,0xf7,0xf8,0xf9,0xfa
  92                 },
  93                 pad: { 0x00, 0x00 }
  94             },
  95             { // chrominance
  96                 num_dc_codes: {
  97                     0x00,0x03,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x00,
  98                     0x00,0x00,0x00,0x00
  99                 },
 100                 dc_values:    {
 101                     0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0a,0x0b
 102                 },
 103                 num_ac_codes: {
 104                     0x00,0x02,0x01,0x02,0x04,0x04,0x03,0x04,0x07,0x05,0x04,0x04,
 105                     0x00,0x01,0x02,0x77
 106                 },
 107                 ac_values:    {
 108                     0x00,0x01,0x02,0x03,0x11,0x04,0x05,0x21,0x31,0x06,0x12,0x41,
 109                     0x51,0x07,0x61,0x71,0x13,0x22,0x32,0x81,0x08,0x14,0x42,0x91,
 110                     0xa1,0xb1,0xc1,0x09,0x23,0x33,0x52,0xf0,0x15,0x62,0x72,0xd1,
 111                     0x0a,0x16,0x24,0x34,0xe1,0x25,0xf1,0x17,0x18,0x19,0x1a,0x26,
 112                     0x27,0x28,0x29,0x2a,0x35,0x36,0x37,0x38,0x39,0x3a,0x43,0x44,
 113                     0x45,0x46,0x47,0x48,0x49,0x4a,0x53,0x54,0x55,0x56,0x57,0x58,
 114                     0x59,0x5a,0x63,0x64,0x65,0x66,0x67,0x68,0x69,0x6a,0x73,0x74,
 115                     0x75,0x76,0x77,0x78,0x79,0x7a,0x82,0x83,0x84,0x85,0x86,0x87,
 116                     0x88,0x89,0x8a,0x92,0x93,0x94,0x95,0x96,0x97,0x98,0x99,0x9a,
 117                     0xa2,0xa3,0xa4,0xa5,0xa6,0xa7,0xa8,0xa9,0xaa,0xb2,0xb3,0xb4,
 118                     0xb5,0xb6,0xb7,0xb8,0xb9,0xba,0xc2,0xc3,0xc4,0xc5,0xc6,0xc7,
 119                     0xc8,0xc9,0xca,0xd2,0xd3,0xd4,0xd5,0xd6,0xd7,0xd8,0xd9,0xda,
 120                     0xe2,0xe3,0xe4,0xe5,0xe6,0xe7,0xe8,0xe9,0xea,0xf2,0xf3,0xf4,
 121                     0xf5,0xf6,0xf7,0xf8,0xf9,0xfa,
 122                 },
 123                 pad: { 0x00, 0x00 }
 124             }
 125         }
 126     };
 127
 128     static const IQMatrix defaultIQMatrix = { /* Quality 100 */
 129         load_quantiser_table: { 0x1,0x1,0x0,0x0 },
 130         quantiser_table: {
 131             {
 132                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 133                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 134                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 135                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 136                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 137                 0x01,0x01,0x01,0x01,
 138             },
 139             {
 140                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 141                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 142                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 143                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 144                 0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,0x01,
 145                 0x01,0x01,0x01,0x01,
 146             },
 147         },
 148     };
 149
 150     static const PictureParameter defaultPictureParameter = {
 151         picture_width:  10,
 152         picture_height: 10,
 153         /* component_id, h_sampling_factor, v_sampling_factor, quantiser_table_selector */
 154         components:     {{1,1,1,0}, {2,1,1,1}, {3,1,1,1}},
 155         num_components: 3,
 156     };
 157
 158     static const SliceParameter defaultSliceParameter = {
 159         slice_data_size:                        0,
 160         slice_data_offset:                      0,
 161         slice_data_flag:                        VA_SLICE_DATA_FLAG_ALL,
 162         slice_horizontal_position:              0,
 163         slice_vertical_position:                0,
 164
 165         /* component_selector, dc_table_selector, ac_table_selector */
 166         components: {{1,0,0},{2,1,1},{3,1,1}},
 167
 168         num_components:                         3,
 169         restart_interval:                       0,
 170         num_mcus:                               4,
 171     };
 172
 173     class PictureData
 174     {
 175     public:
 176         typedef std::shared_ptr<PictureData> Shared;
 177         typedef std::shared_ptr<const PictureData> SharedConst;
 178
 179         template<const unsigned W, const unsigned H>
 180         static SharedConst make(
 181             const unsigned fourcc,
 182             const ByteData& slice,
 183             const SliceParameter& sparam = defaultSliceParameter,
 184             const PictureParameter& pparam = defaultPictureParameter,
 185             const HuffmanTable& huffman = defaultHuffmanTable,
 186             const IQMatrix& iqmatrix = defaultIQMatrix)
 187         {
 188             return make(fourcc, slice, W, H, sparam, pparam, huffman, iqmatrix);
 189         }
 190
 191         static SharedConst make(
 192             const unsigned fourcc,
 193             const ByteData& slice,
 194             const unsigned w, const unsigned h,
 195             const SliceParameter& sparam = defaultSliceParameter,
 196             const PictureParameter& pparam = defaultPictureParameter,
 197             const HuffmanTable& huffman = defaultHuffmanTable,
 198             const IQMatrix& iqmatrix = defaultIQMatrix)
 199         {
 200             Shared pd(
 201                 new PictureData {
 202                     slice: slice,
 203                     sparam: sparam,
 204                     pparam: pparam,
 205                     huffman: huffman,
 206                     iqmatrix: iqmatrix,
 207                     format: 0,
 208                     fourcc: fourcc,
 209                 }
 210             );
 211
 212             pd->sparam.slice_data_size = slice.size();
 213             pd->pparam.picture_width = w;
 214             pd->pparam.picture_height = h;
 215
 216             switch(fourcc)
 217             {
 218             case VA_FOURCC_IMC3:
 219                 pd->format = VA_RT_FORMAT_YUV420;
 220                 pd->pparam.components[0].h_sampling_factor = 2;
 221                 pd->pparam.components[0].v_sampling_factor = 2;
 222                 break;
 223             case VA_FOURCC_422H:
 224                 pd->format = VA_RT_FORMAT_YUV422;
 225                 pd->pparam.components[0].h_sampling_factor = 2;
 226                 pd->pparam.components[0].v_sampling_factor = 1;
 227                 break;
 228             case VA_FOURCC_422V:
 229                 pd->format = VA_RT_FORMAT_YUV422;
 230                 pd->pparam.components[0].h_sampling_factor = 1;
 231                 pd->pparam.components[0].v_sampling_factor = 2;
 232                 break;
 233             case VA_FOURCC_411P:
 234                 pd->format = VA_RT_FORMAT_YUV411;
 235                 pd->pparam.components[0].h_sampling_factor = 4;
 236                 pd->pparam.components[0].v_sampling_factor = 1;
 237                 break;
 238             case VA_FOURCC_444P:
 239                 pd->format = VA_RT_FORMAT_YUV444;
 240                 pd->pparam.components[0].h_sampling_factor = 1;
 241                 pd->pparam.components[0].v_sampling_factor = 1;
 242                 break;
 243             case VA_FOURCC_Y800:
 244                 pd->format = VA_RT_FORMAT_YUV400;
 245                 pd->pparam.components[0].h_sampling_factor = 1;
 246                 pd->pparam.components[0].h_sampling_factor = 1;
 247                 pd->pparam.num_components = 1;
 248                 pd->sparam.num_components = 1;
 249                 break;
 250             default:
 251                 break;
 252             }
 253
 254             /* Calculate num_mcus */
 255             int hfactor = pd->pparam.components[0].h_sampling_factor << 3;
 256             int vfactor = pd->pparam.components[0].v_sampling_factor << 3;
 257             int wmcu = (w + hfactor - 1) / hfactor;
 258             int hmcu = (h + vfactor - 1) / vfactor;
 259             pd->sparam.num_mcus = wmcu * hmcu;
 260
 261             return pd;
 262         }
 263
 264         const ByteData          slice;
 265         SliceParameter          sparam;
 266         PictureParameter        pparam;
 267         HuffmanTable            huffman;
 268         IQMatrix                iqmatrix;
 269         unsigned                format;
 270         unsigned                fourcc;
 271     };
 272
 273     class TestPattern
 274     {
 275     public:
 276         typedef std::shared_ptr<TestPattern> Shared;
 277         typedef std::shared_ptr<const TestPattern> SharedConst;
 278
 279         virtual ~TestPattern() { }
 280
 281         virtual const ByteData& decoded() const = 0;
 282         virtual PictureData::SharedConst encoded(unsigned) const = 0;
 283
 284         virtual void repr(std::ostream&) const = 0;
 285
 286         friend std::ostream& operator <<(std::ostream& os, const TestPattern& t)
 287         {
 288             t.repr(os);
 289             return os;
 290         }
 291     };
 292
 293     template <const unsigned N>
 294     class TestPatternData
 295         : public TestPattern
 296     {
 297     private:
 298         typedef std::map<const unsigned, PictureData::SharedConst> EncodedMap;
 299         typedef std::map<const unsigned, const ByteData> ByteDataMap;
 300
 301     public:
 302         const ByteData& decoded() const { return getDecoded(); }
 303
 304         PictureData::SharedConst encoded(const unsigned fourcc) const
 305         {
 306             const EncodedMap& em = getEncodedMap();
 307             const EncodedMap::const_iterator match(em.find(fourcc));
 308             if (match == em.end())
 309                 return PictureData::SharedConst();
 310             return match->second;
 311         }
 312
 313         void repr(std::ostream& os) const { os << N; }
 314
 315         template <const unsigned W, const unsigned H>
 316         static bool initialize(ByteData d, const ByteDataMap& e)
 317         {
 318             getDecoded().swap(d);
 319
 320             EncodedMap& em = getEncodedMap();
 321             bool result = true;
 322             for (auto const &b : e) {
 323                 auto pd(PictureData::make<W, H>(b.first, b.second));
 324                 auto pair = std::make_pair(b.first, pd);
 325                 result &= em.insert(pair).second;
 326             }
 327             return result;
 328         }
 329
 330     private:
 331         static ByteData& getDecoded()
 332         {
 333             static ByteData d;
 334             return d;
 335         }
 336
 337         static EncodedMap& getEncodedMap()
 338         {
 339             static EncodedMap em;
 340             return em;
 341         }
 342
 343         static const bool m_valid;
 344     };
 345 } // namespace Decode
 346 } // namespace JPEG
 347
 348 namespace JPEG {
 349 namespace Encode {
 350     typedef VAQMatrixBufferJPEG                 IQMatrix;
 351     typedef VAHuffmanTableBufferJPEGBaseline    HuffmanTable;
 352     typedef VAEncPictureParameterBufferJPEG     PictureParameter;
 353     typedef VAEncSliceParameterBufferJPEG       SliceParameter;
 354
 355     static const VAEntrypoint entrypoint = VAEntrypointEncPicture;
 356
 357     static const IQMatrix defaultIQMatrix = { /* Quality 50 */
 358         load_lum_quantiser_matrix: 1,
 359         load_chroma_quantiser_matrix: 1,
 360         lum_quantiser_matrix: {
 361             0x10,0x0b,0x0c,0x0e,0x0c,0x0a,0x10,0x0e,
 362             0x0d,0x0e,0x12,0x11,0x10,0x13,0x18,0x28,
 363             0x1a,0x18,0x16,0x16,0x18,0x31,0x23,0x25,
 364             0x1d,0x28,0x3a,0x33,0x3d,0x3c,0x39,0x33,
 365             0x38,0x37,0x40,0x48,0x5c,0x4e,0x40,0x44,
 366             0x57,0x45,0x37,0x38,0x50,0x6d,0x51,0x57,
 367             0x5f,0x62,0x67,0x68,0x67,0x3e,0x4d,0x71,
 368             0x79,0x70,0x64,0x78,0x5c,0x65,0x67,0x63,
 369         },
 370         chroma_quantiser_matrix: {
 371             0x11,0x12,0x12,0x18,0x15,0x18,0x2f,0x1a,
 372             0x1a,0x2f,0x63,0x42,0x38,0x42,0x63,0x63,
 373             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 374             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 375             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 376             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 377             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 378             0x63,0x63,0x63,0x63,0x63,0x63,0x63,0x63,
 379         },
 380     };
 381
 382     static const HuffmanTable defaultHuffmanTable =
 383         ::JPEG::Decode::defaultHuffmanTable;
 384
 385     static const PictureParameter defaultPictureParameter = {
 386         reconstructed_picture:      VA_INVALID_ID,
 387         picture_width:              10,
 388         picture_height:             10,
 389         coded_buf:                  VA_INVALID_ID,
 390         pic_flags:                  {value: 0x00100},
 391         sample_bit_depth:           8,
 392         num_scan:                   1,
 393         num_components:             3,
 394         component_id:               {0, 1, 2, 0},
 395         quantiser_table_selector:   {0, 1, 1, 0},
 396         quality:                    100,
 397     };
 398
 399     static const SliceParameter defaultSliceParameter = {
 400         restart_interval:   0,
 401         num_components:     3,
 402         /* component_selector, dc_table_selector, ac_table_selector */
 403         components:         {{1,0,0},{2,1,1},{3,1,1}},
 404     };
 405
 406     class TestInput
 407         : public std::enable_shared_from_this<TestInput>
 408     {
 409     public:
 410         typedef std::shared_ptr<TestInput> Shared;
 411         typedef std::shared_ptr<const TestInput> SharedConst;
 412
 413         static Shared create(const unsigned, const unsigned, const unsigned);
 414         const YUVImage::SharedConst toExpectedOutput() const;
 415
 416         friend ::std::ostream& operator<<(::std::ostream&, const TestInput&);
 417         friend ::std::ostream& operator<<(::std::ostream&, const Shared&);
 418         friend ::std::ostream& operator<<(::std::ostream&, const SharedConst&);
 419
 420         YUVImage::Shared    image;
 421         PictureParameter    picture;
 422         IQMatrix            matrix;
 423         HuffmanTable        huffman;
 424         SliceParameter      slice;
 425
 426     private:
 427         TestInput();
 428     };
 429
 430     class TestInputCreator
 431     {
 432     public:
 433         typedef std::shared_ptr<TestInputCreator> Shared;
 434         typedef std::shared_ptr<const TestInputCreator> SharedConst;
 435
 436         virtual ~TestInputCreator() { }
 437
 438         TestInput::Shared create(const unsigned) const;
 439
 440         friend ::std::ostream& operator<<(
 441             ::std::ostream&, const TestInputCreator&);
 442         friend ::std::ostream& operator<<(
 443             ::std::ostream&, const TestInputCreator::Shared&);
 444         friend ::std::ostream& operator<<(
 445             ::std::ostream&, const TestInputCreator::SharedConst&);
 446         virtual std::array<unsigned, 2> getResolution() const = 0;
 447
 448     protected:
 449         virtual void repr(::std::ostream& os) const = 0;
 450     };
 451
 452     class RandomSizeCreator
 453         : public TestInputCreator
 454     {
 455     public:
 456         std::array<unsigned, 2> getResolution() const;
 457
 458     protected:
 459         void repr(::std::ostream&) const;
 460     };
 461
 462     class FixedSizeCreator
 463         : public TestInputCreator
 464     {
 465     public:
 466         FixedSizeCreator(const std::array<unsigned, 2>&);
 467         std::array<unsigned, 2> getResolution() const;
 468
 469     protected:
 470         void repr(::std::ostream& os) const;
 471
 472     private:
 473         const std::array<unsigned, 2> res;
 474     };
 475
 476     typedef std::vector<TestInputCreator::SharedConst> InputCreators;
 477
 478 } // namespace Encode
 479 } // namespace JPEG
 480
 481 #endif