Lines Matching full:tile
28 * tile (but taking care to pass the full frame stride length to
30 * to convert each tile back-to-back when possible (see note below
45 * reusable temporary tile buffer and then rotating with the 8x8
61 * With rotation or flipping, tile order changes between input and
96 /* dimensions of one tile */
106 /* start Y or packed offset of this tile */
108 /* offset from start to tile in U plane, for planar formats */
110 /* offset from start to tile in V plane, for planar formats */
126 struct ipu_image_tile tile[MAX_TILES];
185 /* next tile to process */
187 /* where to place converted tile in dest image */
190 /* mask of completed EOF irqs at every tile conversion */
392 * Also determine the number of tiles necessary to guarantee that no tile
432 * we were converting with a single tile. The bottom right output pixel
517 * Limit input seam position to make sure that the downsized input tile
552 * start the input tile at, 19.13 fixed point.
585 * Tile left edges are required to be aligned to multiples of 8 bytes
597 * Tile top edge alignment is only limited by chroma subsampling.
649 * tiles are in a row, and output tile top position and height are set.
663 in_tile = &in->tile[tile_idx];
664 out_tile = &out->tile[ctx->out_tile_map[tile_idx]];
682 * tiles are in a column, and output tile left position and width are set.
695 in_tile = &in->tile[tile_idx];
696 out_tile = &out->tile[ctx->out_tile_map[tile_idx]];
714 * top / left pixels of each tile.
850 /* Up to 4096x4096 input tile size */
856 struct ipu_image_tile *tile;
861 tile = &image->tile[ctx->out_tile_map[i]];
863 tile = &image->tile[i];
865 tile->size = ((tile->height * image->fmt->bpp) >> 3) *
866 tile->width;
869 tile->stride = tile->width;
870 tile->rot_stride = tile->height;
872 tile->stride =
873 (image->fmt->bpp * tile->width) >> 3;
874 tile->rot_stride =
875 (image->fmt->bpp * tile->height) >> 3;
883 tile->width, tile->height, tile->left, tile->top);
885 if (!tile->width || tile->width > max_width ||
886 !tile->height || tile->height > max_height) {
887 dev_err(priv->ipu->dev, "invalid %s tile size: %ux%u\n",
889 "output", tile->width, tile->height);
898 * Use the rotation transformation to find the tile coordinates
899 * (row, col) of a tile in the destination frame that corresponds
900 * to the given tile coordinates of a source frame. The destination
901 * coordinate is then converted to a tile index.
954 * Fill the out_tile_map[] with transformed destination tile indeces.
959 unsigned int row, col, tile = 0;
963 ctx->out_tile_map[tile] =
965 tile++;
976 unsigned int row, col, tile = 0;
994 top = image->tile[tile].top;
999 y_col_off = image->tile[tile].left;
1012 image->tile[tile].offset = y_off;
1013 image->tile[tile].u_off = u_off;
1014 image->tile[tile++].v_off = v_off;
1038 unsigned int row, col, tile = 0;
1047 row_off = image->tile[tile].top * stride;
1050 col_off = (image->tile[tile].left * bpp) >> 3;
1054 image->tile[tile].offset = offset;
1055 image->tile[tile].u_off = 0;
1056 image->tile[tile++].v_off = 0;
1086 * Either round to closest for the next tile's first pixel to minimize seams
1088 * avoid sampling beyond the edges of the input image for this tile's last
1104 * Slightly modify resize coefficients per tile to hide the bilinear
1105 * interpolator reset at tile borders, shifting the right / bottom edge
1125 in_tile = &ctx->in.tile[tile_idx];
1126 out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
1160 in_tile = &ctx->in.tile[tile_idx];
1161 out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
1182 in_tile = &ctx->in.tile[tile_idx];
1183 out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
1217 in_tile = &ctx->in.tile[tile_idx];
1218 out_tile = &ctx->out.tile[ctx->out_tile_map[tile_idx]];
1280 unsigned int tile)
1290 tile_idx[0] = ctx->out_tile_map[tile];
1293 tile_idx[0] = tile;
1298 width = image->tile[tile_idx[0]].height;
1299 height = image->tile[tile_idx[0]].width;
1300 stride = image->tile[tile_idx[0]].rot_stride;
1305 width = image->tile[tile_idx[0]].width;
1306 height = image->tile[tile_idx[0]].height;
1309 image->tile[tile_idx[0]].offset;
1312 image->tile[tile_idx[1]].offset;
1325 tile_image.u_offset = image->tile[tile_idx[0]].u_off;
1326 tile_image.v_offset = image->tile[tile_idx[0]].v_off;
1365 static int convert_start(struct ipu_image_convert_run *run, unsigned int tile)
1372 unsigned int dst_tile = ctx->out_tile_map[tile];
1378 dev_dbg(priv->ipu->dev, "%s: task %u: starting ctx %p run %p tile %u -> %u\n",
1379 __func__, chan->ic_task, ctx, run, tile, dst_tile);
1386 dest_width = d_image->tile[dst_tile].height;
1387 dest_height = d_image->tile[dst_tile].width;
1389 dest_width = d_image->tile[dst_tile].width;
1390 dest_height = d_image->tile[dst_tile].height;
1393 row = tile / s_image->num_cols;
1394 col = tile % s_image->num_cols;
1402 __func__, s_image->tile[tile].width,
1403 s_image->tile[tile].height, dest_width, dest_height, rsc);
1407 s_image->tile[tile].width,
1408 s_image->tile[tile].height,
1419 IPU_ROTATE_NONE, false, tile);
1424 IPU_ROTATE_NONE, true, tile);
1428 ctx->rot_mode, true, tile);
1432 IPU_ROTATE_NONE, false, tile);
1439 ctx->rot_mode, false, tile);
1609 ctx->in.tile[cur_tile].width != ctx->in.tile[next_tile].width ||
1610 ctx->in.tile[cur_tile].height != ctx->in.tile[next_tile].height ||
1611 ctx->out.tile[cur_tile].width != ctx->out.tile[next_tile].width ||
1612 ctx->out.tile[cur_tile].height != ctx->out.tile[next_tile].height)
1658 * not done, place the next tile buffers.
1665 src_tile = &s_image->tile[ctx->next_tile];
1667 dst_tile = &d_image->tile[dst_idx];
1689 src_tile = &s_image->tile[ctx->next_tile + 1];
1691 dst_tile = &d_image->tile[dst_idx];
1704 ctx->eof_mask = 0; /* clear EOF irq mask for next tile */
2160 * only one tile (the whole image can be converted in a single
2164 * for every tile, and therefore would have to be updated for
2168 * sized tiles or different resizing coefficients per tile
2175 if (ctx->in.tile[i].width != ctx->in.tile[0].width ||
2176 ctx->in.tile[i].height != ctx->in.tile[0].height ||
2177 ctx->out.tile[i].width != ctx->out.tile[0].width ||
2178 ctx->out.tile[i].height != ctx->out.tile[0].height) {
2197 unsigned long intermediate_size = d_image->tile[0].size;
2200 if (d_image->tile[i].size > intermediate_size)
2201 intermediate_size = d_image->tile[i].size;