← Back to branch summary

~ubuntu-branches/ubuntu/wily/libde265/wily

« back to all changes in this revision

Viewing changes to libde265/intrapred.cc

  • Committer: Package Import Robot
  • Author(s): Joachim Bauch
  • Date: 2015-07-16 11:07:46 UTC
  • mfrom: (2.1.2 sid)
  • Revision ID: package-import@ubuntu.com-20150716110746-76vsv24j3yux7tnu
Tags: 1.0.2-1
* Imported Upstream version 1.0.2
* Added new files to copyright information.
* Only export decoder API and update symbols for new version.

Show diffs side-by-side

added added

removed removed

Lines of Context:
libde265/intrapred.cc
29
29
 
30
30
 
31
31
#ifdef DE265_LOG_TRACE
32
 
void print_border(uint8_t* data, uint8_t* available, int nT)
 
32
template <class pixel_t>
 
33
void print_border(pixel_t* data, uint8_t* available, int nT)
33
34
{
34
35
  for (int i=-2*nT ; i<=2*nT ; i++) {
35
36
    if (i==0 || i==1 || i==-nT || i==nT+1) {
51
52
#endif
52
53
 
53
54
 
 
55
void fillIntraPredModeCandidates(int candModeList[3], int x,int y, int PUidx,
 
56
                                 bool availableA, // left
 
57
                                 bool availableB, // top
 
58
                                 const de265_image* img)
 
59
{
 
60
  const seq_parameter_set* sps = &img->sps;
 
61
 
 
62
  // block on left side
 
63
 
 
64
  enum IntraPredMode candIntraPredModeA, candIntraPredModeB;
 
65
  if (availableA==false) {
 
66
    candIntraPredModeA=INTRA_DC;
 
67
  }
 
68
  else if (img->get_pred_mode(x-1,y) != MODE_INTRA ||
 
69
           img->get_pcm_flag (x-1,y)) {
 
70
    candIntraPredModeA=INTRA_DC;
 
71
 }
 
72
  else {
 
73
    candIntraPredModeA = img->get_IntraPredMode_atIndex(PUidx-1);
 
74
  }
 
75
 
 
76
  // block above
 
77
 
 
78
  if (availableB==false) {
 
79
    candIntraPredModeB=INTRA_DC;
 
80
  }
 
81
  else if (img->get_pred_mode(x,y-1) != MODE_INTRA ||
 
82
           img->get_pcm_flag (x,y-1)) {
 
83
    candIntraPredModeB=INTRA_DC;
 
84
  }
 
85
  else if (y-1 < ((y >> sps->Log2CtbSizeY) << sps->Log2CtbSizeY)) {
 
86
    candIntraPredModeB=INTRA_DC;
 
87
  }
 
88
  else {
 
89
    candIntraPredModeB = img->get_IntraPredMode_atIndex(PUidx-sps->PicWidthInMinPUs);
 
90
  }
 
91
 
 
92
 
 
93
  // build candidate list
 
94
 
 
95
  logtrace(LogSlice,"%d;%d availableA:%d candA:%d & availableB:%d candB:%d\n", x,y,
 
96
           availableA, candIntraPredModeA,
 
97
           availableB, candIntraPredModeB);
 
98
 
 
99
  if (candIntraPredModeA == candIntraPredModeB) {
 
100
    if (candIntraPredModeA < 2) {
 
101
      candModeList[0] = INTRA_PLANAR;
 
102
      candModeList[1] = INTRA_DC;
 
103
      candModeList[2] = INTRA_ANGULAR_26;
 
104
    }
 
105
    else {
 
106
      candModeList[0] = candIntraPredModeA;
 
107
      candModeList[1] = 2 + ((candIntraPredModeA-2 -1 +32) % 32);
 
108
      candModeList[2] = 2 + ((candIntraPredModeA-2 +1    ) % 32);
 
109
    }
 
110
  }
 
111
  else {
 
112
    candModeList[0] = candIntraPredModeA;
 
113
    candModeList[1] = candIntraPredModeB;
 
114
 
 
115
    if (candIntraPredModeA != INTRA_PLANAR &&
 
116
        candIntraPredModeB != INTRA_PLANAR) {
 
117
      candModeList[2] = INTRA_PLANAR;
 
118
    }
 
119
    else if (candIntraPredModeA != INTRA_DC &&
 
120
             candIntraPredModeB != INTRA_DC) {
 
121
      candModeList[2] = INTRA_DC;
 
122
    }
 
123
    else {
 
124
      candModeList[2] = INTRA_ANGULAR_26;
 
125
    }
 
126
  }
 
127
 
 
128
  /*
 
129
    printf("candModeList: %d %d %d\n",
 
130
    candModeList[0],
 
131
    candModeList[1],
 
132
    candModeList[2]
 
133
    );
 
134
  */
 
135
}
 
136
 
 
137
 
 
138
int find_intra_pred_mode(enum IntraPredMode mode,
 
139
                         int candModeList[3])
 
140
{
 
141
  // check whether the mode is in the candidate list
 
142
 
 
143
  for (int i=0;i<3;i++) {
 
144
    if (candModeList[i] == mode) {
 
145
      return i;
 
146
    }
 
147
  }
 
148
 
 
149
  // sort candModeList
 
150
 
 
151
  if (candModeList[0] > candModeList[1]) {
 
152
    std::swap(candModeList[0],candModeList[1]);
 
153
  }
 
154
  if (candModeList[0] > candModeList[2]) {
 
155
    std::swap(candModeList[0],candModeList[2]);
 
156
  }
 
157
  if (candModeList[1] > candModeList[2]) {
 
158
    std::swap(candModeList[1],candModeList[2]);
 
159
  }
 
160
 
 
161
  // skip modes already in the candidate list
 
162
 
 
163
  int intraMode = mode;
 
164
 
 
165
  for (int i=2;i>=0;i--) {
 
166
    if (intraMode >= candModeList[i]) { intraMode--; }
 
167
  }
 
168
 
 
169
  return -intraMode-1;
 
170
}
 
171
 
 
172
 
 
173
void list_chroma_pred_candidates(enum IntraPredMode chroma_mode[5],
 
174
                                 enum IntraPredMode luma_mode)
 
175
{
 
176
  enum IntraPredMode chroma_cand[5];
 
177
  chroma_cand[0] = INTRA_PLANAR;
 
178
  chroma_cand[1] = INTRA_ANGULAR_26;
 
179
  chroma_cand[2] = INTRA_ANGULAR_10;
 
180
  chroma_cand[3] = INTRA_DC;
 
181
  chroma_cand[4] = luma_mode;
 
182
 
 
183
  switch (luma_mode) {
 
184
  case INTRA_PLANAR:     chroma_cand[0] = INTRA_ANGULAR_34; break;
 
185
  case INTRA_ANGULAR_26: chroma_cand[1] = INTRA_ANGULAR_34; break;
 
186
  case INTRA_ANGULAR_10: chroma_cand[2] = INTRA_ANGULAR_34; break;
 
187
  case INTRA_DC:         chroma_cand[3] = INTRA_ANGULAR_34; break;
 
188
  default:
 
189
    // use defaults from above
 
190
    break;
 
191
  }
 
192
}
 
193
 
 
194
 
 
195
int get_intra_scan_idx(int log2TrafoSize, enum IntraPredMode intraPredMode, int cIdx,
 
196
                       const seq_parameter_set* sps)
 
197
{
 
198
  if (log2TrafoSize==2 ||
 
199
      (log2TrafoSize==3 && (cIdx==0 ||
 
200
                            sps->ChromaArrayType==CHROMA_444))) {
 
201
    /**/ if (intraPredMode >=  6 && intraPredMode <= 14) return 2;
 
202
    else if (intraPredMode >= 22 && intraPredMode <= 30) return 1;
 
203
    else return 0;
 
204
  }
 
205
  else { return 0; }
 
206
}
 
207
 
 
208
 
 
209
int get_intra_scan_idx_luma(int log2TrafoSize, enum IntraPredMode intraPredMode)
 
210
{
 
211
  if (log2TrafoSize==2 || log2TrafoSize==3) {
 
212
    /**/ if (intraPredMode >=  6 && intraPredMode <= 14) return 2;
 
213
    else if (intraPredMode >= 22 && intraPredMode <= 30) return 1;
 
214
    else return 0;
 
215
  }
 
216
  else { return 0; }
 
217
}
 
218
 
 
219
int get_intra_scan_idx_chroma(int log2TrafoSize, enum IntraPredMode intraPredMode)
 
220
{
 
221
  if (log2TrafoSize==1 || log2TrafoSize==2) {
 
222
    /**/ if (intraPredMode >=  6 && intraPredMode <= 14) return 2;
 
223
    else if (intraPredMode >= 22 && intraPredMode <= 30) return 1;
 
224
    else return 0;
 
225
  }
 
226
  else { return 0; }
 
227
}
 
228
 
 
229
 
 
230
enum IntraPredMode lumaPredMode_to_chromaPredMode(enum IntraPredMode luma,
 
231
                                                  enum IntraChromaPredMode chroma)
 
232
{
 
233
  switch (chroma) {
 
234
  case INTRA_CHROMA_LIKE_LUMA:
 
235
    return luma;
 
236
 
 
237
  case INTRA_CHROMA_PLANAR_OR_34:
 
238
    if (luma==INTRA_PLANAR) return INTRA_ANGULAR_34;
 
239
    else                    return INTRA_PLANAR;
 
240
 
 
241
  case INTRA_CHROMA_ANGULAR_26_OR_34:
 
242
    if (luma==INTRA_ANGULAR_26) return INTRA_ANGULAR_34;
 
243
    else                        return INTRA_ANGULAR_26;
 
244
 
 
245
  case INTRA_CHROMA_ANGULAR_10_OR_34:
 
246
    if (luma==INTRA_ANGULAR_10) return INTRA_ANGULAR_34;
 
247
    else                        return INTRA_ANGULAR_10;
 
248
 
 
249
  case INTRA_CHROMA_DC_OR_34:
 
250
    if (luma==INTRA_DC)         return INTRA_ANGULAR_34;
 
251
    else                        return INTRA_DC;
 
252
  }
 
253
 
 
254
 
 
255
  assert(false);
 
256
  return INTRA_DC;
 
257
}
 
258
 
 
259
 
54
260
// (8.4.4.2.2)
55
 
void fill_border_samples(de265_image* img, int xB,int yB,
 
261
template <class pixel_t>
 
262
void fill_border_samples(de265_image* img,
 
263
                         int xB,int yB,  // in component specific resolution
56
264
                         int nT, int cIdx,
57
 
                         uint8_t* out_border)
 
265
                         pixel_t* out_border)
58
266
{
59
267
  const seq_parameter_set* sps = &img->sps;
60
268
  const pic_parameter_set* pps = &img->pps;
62
270
  uint8_t available_data[2*64 + 1];
63
271
  uint8_t* available = &available_data[64];
64
272
 
65
 
  uint8_t* image;
 
273
  pixel_t* image;
66
274
  int stride;
67
 
  image  = img->get_image_plane(cIdx);
 
275
  image  = (pixel_t*)img->get_image_plane(cIdx);
68
276
  stride = img->get_image_stride(cIdx);
69
277
 
70
 
  const int chromaShift = (cIdx==0) ? 0 : 1;
71
 
  const int TUShift = (cIdx==0) ? sps->Log2MinTrafoSize : sps->Log2MinTrafoSize-1;
 
278
  const int SubWidth  = (cIdx==0) ? 1 : sps->SubWidthC;
 
279
  const int SubHeight = (cIdx==0) ? 1 : sps->SubHeightC;
72
280
 
 
281
  const int bit_depth = img->get_bit_depth(cIdx);
73
282
 
74
283
  // --- check for CTB boundaries ---
75
284
 
76
 
  int xBLuma = (cIdx==0) ? xB : 2*xB;
77
 
  int yBLuma = (cIdx==0) ? yB : 2*yB;
78
 
  int nTLuma = (cIdx==0) ? nT : 2*nT;
 
285
  int xBLuma = xB * SubWidth;
 
286
  int yBLuma = yB * SubHeight;
79
287
 
80
288
  int log2CtbSize = sps->Log2CtbSizeY;
81
289
  int picWidthInCtbs = sps->PicWidthInCtbsY;
86
294
  bool availableTopLeft=true;  // if CTB at top-left pixel available?
87
295
 
88
296
 
 
297
  //printf("xB/yB: %d %d\n",xB,yB);
 
298
 
89
299
  // are we at left image border
90
300
 
91
301
  if (xBLuma == 0) {
104
314
    yBLuma = 0; // fake value, available flags are already set to false
105
315
  }
106
316
 
107
 
  if (xBLuma+nTLuma >= sps->pic_width_in_luma_samples) {
 
317
  if (xBLuma+nT*SubWidth >= sps->pic_width_in_luma_samples) {
108
318
    availableTopRight=false;
109
319
  }
110
 
 
 
320
 
111
321
  // check for tile and slice boundaries
112
322
 
113
323
  int xCurrCtb = xBLuma >> log2CtbSize;
114
324
  int yCurrCtb = yBLuma >> log2CtbSize;
115
325
  int xLeftCtb = (xBLuma-1) >> log2CtbSize;
116
 
  int xRightCtb = (xBLuma+nTLuma) >> log2CtbSize;
 
326
  int xRightCtb = (xBLuma+nT*SubWidth) >> log2CtbSize;
117
327
  int yTopCtb   = (yBLuma-1) >> log2CtbSize;
118
328
 
119
329
  int currCTBSlice = img->get_SliceAddrRS(xCurrCtb,yCurrCtb);
122
332
  int toprightCTBSlice = availableTopRight ? img->get_SliceAddrRS(xRightCtb, yTopCtb) : -1;
123
333
  int topleftCTBSlice  = availableTopLeft  ? img->get_SliceAddrRS(xLeftCtb, yTopCtb) : -1;
124
334
 
 
335
  /*
 
336
  printf("size: %d\n",pps->TileIdRS.size());
 
337
  printf("curr: %d left: %d top: %d\n",
 
338
         xCurrCtb+yCurrCtb*picWidthInCtbs,
 
339
         availableLeft ? xLeftCtb+yCurrCtb*picWidthInCtbs : 9999,
 
340
         availableTop  ? xCurrCtb+yTopCtb*picWidthInCtbs  : 9999);
 
341
  */
125
342
  int currCTBTileID = pps->TileIdRS[xCurrCtb+yCurrCtb*picWidthInCtbs];
126
343
  int leftCTBTileID = availableLeft ? pps->TileIdRS[xLeftCtb+yCurrCtb*picWidthInCtbs] : -1;
127
344
  int topCTBTileID  = availableTop ? pps->TileIdRS[xCurrCtb+yTopCtb*picWidthInCtbs] : -1;
139
356
 
140
357
  // number of pixels that are in the valid image area to the right and to the bottom
141
358
 
142
 
  int nBottom = sps->pic_height_in_luma_samples - (cIdx==0 ? yB : 2*yB);
143
 
  if (cIdx) nBottom=(nBottom+1)/2;
 
359
  int nBottom = sps->pic_height_in_luma_samples - yB*SubHeight;
 
360
  nBottom=(nBottom+SubHeight-1)/SubHeight;
144
361
  if (nBottom>2*nT) nBottom=2*nT;
145
 
  int nRight  = sps->pic_width_in_luma_samples  - (cIdx==0 ? xB : 2*xB);
146
 
  if (cIdx) nRight =(nRight +1)/2;
 
362
 
 
363
  int nRight  = sps->pic_width_in_luma_samples  - xB*SubWidth;
 
364
  nRight =(nRight +SubWidth-1)/SubWidth;
147
365
  if (nRight >2*nT) nRight=2*nT;
148
366
 
149
367
  int nAvail=0;
150
368
 
151
 
  uint8_t firstValue;
 
369
  pixel_t firstValue;
152
370
 
153
371
  memset(available-2*nT, 0, 4*nT+1);
154
372
 
158
376
    for (int y=nBottom-1 ; y>=0 ; y-=4)
159
377
      if (availableLeft)
160
378
        {
161
 
          int NBlockAddr = pps->MinTbAddrZS[ ((xB-1)>>TUShift) +
162
 
                                             ((yB+y)>>TUShift) * sps->PicWidthInTbsY ];
163
 
        
164
 
          bool availableN = NBlockAddr < currBlockAddr;
 
379
          int NBlockAddr = pps->MinTbAddrZS[ (((xB-1)*SubWidth )>>sps->Log2MinTrafoSize) +
 
380
                                             (((yB+y)*SubHeight)>>sps->Log2MinTrafoSize)
 
381
                                             * sps->PicWidthInTbsY ];
 
382
 
 
383
          bool availableN = NBlockAddr <= currBlockAddr;
165
384
 
166
385
          if (pps->constrained_intra_pred_flag) {
167
 
            if (img->get_pred_mode((xB-1)<<chromaShift,(yB+y)<<chromaShift)!=MODE_INTRA)
 
386
            if (img->get_pred_mode((xB-1)*SubWidth,(yB+y)*SubHeight)!=MODE_INTRA)
168
387
              availableN = false;
169
388
          }
170
389
 
184
403
 
185
404
    if (availableTopLeft)
186
405
      {
187
 
        int NBlockAddr = pps->MinTbAddrZS[ ((xB-1)>>TUShift) +
188
 
                                           ((yB-1)>>TUShift) * sps->PicWidthInTbsY ];
 
406
        int NBlockAddr = pps->MinTbAddrZS[ (((xB-1)*SubWidth )>>sps->Log2MinTrafoSize) +
 
407
                                           (((yB-1)*SubHeight)>>sps->Log2MinTrafoSize)
 
408
                                           * sps->PicWidthInTbsY ];
189
409
 
190
 
        bool availableN = NBlockAddr < currBlockAddr;
 
410
        bool availableN = NBlockAddr <= currBlockAddr;
191
411
 
192
412
        if (pps->constrained_intra_pred_flag) {
193
 
          if (img->get_pred_mode((xB-1)<<chromaShift,(yB-1)<<chromaShift)!=MODE_INTRA) {
 
413
          if (img->get_pred_mode((xB-1)*SubWidth,(yB-1)*SubHeight)!=MODE_INTRA) {
194
414
            availableN = false;
195
415
          }
196
416
        }
213
433
 
214
434
      if (borderAvailable)
215
435
        {
216
 
          int NBlockAddr = pps->MinTbAddrZS[ ((xB+x)>>TUShift) +
217
 
                                             ((yB-1)>>TUShift) * sps->PicWidthInTbsY ];
 
436
          int NBlockAddr = pps->MinTbAddrZS[ (((xB+x)*SubWidth )>>sps->Log2MinTrafoSize) +
 
437
                                             (((yB-1)*SubHeight)>>sps->Log2MinTrafoSize)
 
438
                                             * sps->PicWidthInTbsY ];
218
439
 
219
 
          bool availableN = NBlockAddr < currBlockAddr;
 
440
          bool availableN = NBlockAddr <= currBlockAddr;
220
441
 
221
442
          if (pps->constrained_intra_pred_flag) {
222
 
            if (img->get_pred_mode((xB+x)<<chromaShift,(yB-1)<<chromaShift)!=MODE_INTRA) {
 
443
            if (img->get_pred_mode((xB+x)*SubWidth,(yB-1)*SubHeight)!=MODE_INTRA) {
223
444
              availableN = false;
224
445
            }
225
446
          }
243
464
 
244
465
    if (nAvail!=4*nT+1) {
245
466
      if (nAvail==0) {
246
 
        memset(out_border-2*nT, 1<<(sps->bit_depth_luma-1), 4*nT+1);
 
467
        if (sizeof(pixel_t)==1) {
 
468
          memset(out_border-2*nT, 1<<(bit_depth-1), 4*nT+1);
 
469
        }
 
470
        else {
 
471
          for (int i = -2*nT; i <= 2*nT ; i++) {
 
472
            out_border[i] = 1<<(bit_depth-1);
 
473
          }
 
474
        }
247
475
      }
248
476
      else {
249
477
        if (!available[-2*nT]) {
269
497
 
270
498
 
271
499
// (8.4.4.2.3)
 
500
template <class pixel_t>
272
501
void intra_prediction_sample_filtering(de265_image* img,
273
 
                                       uint8_t* p,
274
 
                                       int nT,
 
502
                                       pixel_t* p,
 
503
                                       int nT, int cIdx,
275
504
                                       enum IntraPredMode intraPredMode)
276
505
{
277
506
  int filterFlag;
293
522
 
294
523
  if (filterFlag) {
295
524
    int biIntFlag = (img->sps.strong_intra_smoothing_enable_flag &&
 
525
                     cIdx==0 &&
296
526
                     nT==32 &&
297
527
                     abs_value(p[0]+p[ 64]-2*p[ 32]) < (1<<(img->sps.bit_depth_luma-5)) &&
298
528
                     abs_value(p[0]+p[-64]-2*p[-32]) < (1<<(img->sps.bit_depth_luma-5)))
299
529
      ? 1 : 0;
300
530
 
301
 
    uint8_t  pF_mem[2*64+1];
302
 
    uint8_t* pF = &pF_mem[64];
 
531
    pixel_t  pF_mem[2*64+1];
 
532
    pixel_t* pF = &pF_mem[64];
303
533
 
304
534
    if (biIntFlag) {
305
535
      pF[-2*nT] = p[-2*nT];
323
553
 
324
554
    // copy back to original array
325
555
 
326
 
    memcpy(p-2*nT, pF-2*nT, 4*nT+1);
 
556
    memcpy(p-2*nT, pF-2*nT, (4*nT+1) * sizeof(pixel_t));
327
557
  }
328
558
  else {
329
559
    // do nothing ?
345
575
    -315,-390,-482,-630,-910,-1638,-4096 };
346
576
 
347
577
 
348
 
// TODO: clip to read BitDepthY
349
 
LIBDE265_INLINE static int Clip1Y(int x) { if (x<0) return 0; else if (x>255) return 255; else return x; }
350
 
 
351
 
 
352
578
// (8.4.4.2.6)
 
579
template <class pixel_t>
353
580
void intra_prediction_angular(de265_image* img,
354
581
                              int xB0,int yB0,
355
582
                              enum IntraPredMode intraPredMode,
356
583
                              int nT,int cIdx,
357
 
                              uint8_t* border)
 
584
                              pixel_t* border)
358
585
{
359
 
  uint8_t  ref_mem[2*64+1];
360
 
  uint8_t* ref=&ref_mem[64];
 
586
  pixel_t  ref_mem[2*64+1];
 
587
  pixel_t* ref=&ref_mem[64];
361
588
 
362
 
  uint8_t* pred;
 
589
  pixel_t* pred;
363
590
  int      stride;
364
 
  pred   = img->get_image_plane_at_pos(cIdx,xB0,yB0);
 
591
  pred   = img->get_image_plane_at_pos_NEW<pixel_t>(cIdx,xB0,yB0);
365
592
  stride = img->get_image_stride(cIdx);
366
593
 
 
594
  int bit_depth = img->get_bit_depth(cIdx);
 
595
 
 
596
  assert(intraPredMode<35);
 
597
  assert(intraPredMode>=2);
 
598
 
367
599
  int intraPredAngle = intraPredAngle_table[intraPredMode];
368
600
 
 
601
  bool disableIntraBoundaryFilter =
 
602
    (img->sps.range_extension.implicit_rdpcm_enabled_flag &&
 
603
     img->get_cu_transquant_bypass(xB0,yB0));
 
604
 
369
605
  if (intraPredMode >= 18) {
370
606
 
371
607
    for (int x=0;x<=nT;x++)
398
634
          }
399
635
        }
400
636
 
401
 
    if (intraPredMode==26 && cIdx==0 && nT<32) {
 
637
    if (intraPredMode==26 && cIdx==0 && nT<32 && !disableIntraBoundaryFilter) {
402
638
      for (int y=0;y<nT;y++) {
403
 
        pred[0+y*stride] = Clip1Y(border[1] + ((border[-1-y] - border[0])>>1));
 
639
        pred[0+y*stride] = Clip_BitDepth(border[1] + ((border[-1-y] - border[0])>>1), bit_depth);
404
640
      }
405
641
    }
406
642
  }
436
672
          }
437
673
        }
438
674
 
439
 
    if (intraPredMode==10 && cIdx==0 && nT<32) {  // DIFF 26->10
 
675
    if (intraPredMode==10 && cIdx==0 && nT<32 && !disableIntraBoundaryFilter) {  // DIFF 26->10
440
676
      for (int x=0;x<nT;x++) { // DIFF (x<->y)
441
 
        pred[x] = Clip1Y(border[-1] + ((border[1+x] - border[0])>>1)); // DIFF (x<->y && neg)
 
677
        pred[x] = Clip_BitDepth(border[-1] + ((border[1+x] - border[0])>>1), bit_depth); // DIFF (x<->y && neg)
442
678
      }
443
679
    }
444
680
  }
456
692
}
457
693
 
458
694
 
 
695
template <class pixel_t>
459
696
void intra_prediction_planar(de265_image* img,int xB0,int yB0,int nT,int cIdx,
460
 
                             uint8_t* border)
 
697
                             pixel_t* border)
461
698
{
462
 
  uint8_t* pred;
 
699
  pixel_t* pred;
463
700
  int      stride;
464
 
  pred = img->get_image_plane_at_pos(cIdx,xB0,yB0);
 
701
  pred   = img->get_image_plane_at_pos_NEW<pixel_t>(cIdx,xB0,yB0);
465
702
  stride = img->get_image_stride(cIdx);
466
703
 
467
704
  int Log2_nT = Log2(nT);
486
723
}
487
724
 
488
725
 
 
726
template <class pixel_t>
489
727
void intra_prediction_DC(de265_image* img,int xB0,int yB0,int nT,int cIdx,
490
 
                         uint8_t* border)
 
728
                         pixel_t* border)
491
729
{
492
 
  uint8_t* pred;
 
730
  pixel_t* pred;
493
731
  int      stride;
494
 
  pred = img->get_image_plane_at_pos(cIdx,xB0,yB0);
 
732
  pred   = img->get_image_plane_at_pos_NEW<pixel_t>(cIdx,xB0,yB0);
495
733
  stride = img->get_image_stride(cIdx);
496
734
 
497
735
  int Log2_nT = Log2(nT);
525
763
  }
526
764
 
527
765
 
528
 
  /*
529
 
  printf("INTRAPRED DC\n");
530
 
  for (int y=0;y<nT;y++) {
531
 
    for (int x=0;x<nT;x++)
532
 
      {
533
 
        printf("%d ",pred[x+y*stride]);
534
 
      }
535
 
    printf("\n");
 
766
  logtrace(LogIntraPred,"INTRAPRED DC\n");
 
767
  for (int y=0;y<nT;y++)
 
768
    {
 
769
      for (int x=0;x<nT;x++)
 
770
        logtrace(LogIntraPred,"%02x ", pred[x+y*stride]);
 
771
 
 
772
      logtrace(LogIntraPred,"\n");
 
773
    }
 
774
}
 
775
 
 
776
 
 
777
 
 
778
template <class pixel_t>
 
779
void decode_intra_prediction_internal(de265_image* img,
 
780
                                      int xB0,int yB0,
 
781
                                      enum IntraPredMode intraPredMode,
 
782
                                      int nT, int cIdx)
 
783
{
 
784
  pixel_t  border_pixels_mem[2*64+1];
 
785
  pixel_t* border_pixels = &border_pixels_mem[64];
 
786
 
 
787
  fill_border_samples(img, xB0,yB0, nT, cIdx, border_pixels);
 
788
 
 
789
  if (img->sps.range_extension.intra_smoothing_disabled_flag == 0 &&
 
790
      (cIdx==0 || img->sps.ChromaArrayType==CHROMA_444))
 
791
    {
 
792
      intra_prediction_sample_filtering(img, border_pixels, nT, cIdx, intraPredMode);
 
793
    }
 
794
 
 
795
 
 
796
  switch (intraPredMode) {
 
797
  case INTRA_PLANAR:
 
798
    intra_prediction_planar(img,xB0,yB0,nT,cIdx, border_pixels);
 
799
    break;
 
800
  case INTRA_DC:
 
801
    intra_prediction_DC(img,xB0,yB0,nT,cIdx, border_pixels);
 
802
    break;
 
803
  default:
 
804
    intra_prediction_angular(img,xB0,yB0,intraPredMode,nT,cIdx, border_pixels);
 
805
    break;
536
806
  }
537
 
  */
538
807
}
539
808
 
540
809
 
541
 
 
542
810
// (8.4.4.2.1)
543
811
void decode_intra_prediction(de265_image* img,
544
812
                             int xB0,int yB0,
552
820
    xB0,yB0, intraPredMode, nT,cIdx);
553
821
  */
554
822
 
555
 
  uint8_t  border_pixels_mem[2*64+1];
556
 
  uint8_t* border_pixels = &border_pixels_mem[64];
557
 
 
558
 
  fill_border_samples(img, xB0,yB0, nT, cIdx, border_pixels);
559
 
 
560
 
  if (cIdx==0) {
561
 
    intra_prediction_sample_filtering(img, border_pixels, nT, intraPredMode);
 
823
  if (img->high_bit_depth(cIdx)) {
 
824
    decode_intra_prediction_internal<uint16_t>(img,xB0,yB0, intraPredMode,nT,cIdx);
562
825
  }
563
 
 
564
 
 
565
 
  switch (intraPredMode) {
566
 
  case INTRA_PLANAR:
567
 
    intra_prediction_planar(img,xB0,yB0,nT,cIdx, border_pixels);
568
 
    break;
569
 
  case INTRA_DC:
570
 
    intra_prediction_DC(img,xB0,yB0,nT,cIdx, border_pixels);
571
 
    break;
572
 
  default:
573
 
    intra_prediction_angular(img,xB0,yB0,intraPredMode,nT,cIdx, border_pixels);
574
 
    break;
 
826
  else {
 
827
    decode_intra_prediction_internal<uint8_t>(img,xB0,yB0, intraPredMode,nT,cIdx);
575
828
  }
576
829
}
577
 
 
578