root/drivers/media/platform/coda/coda-h264.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. coda_find_nal_header
  2. coda_sps_parse_profile
  3. coda_h264_filler_nal
  4. coda_h264_padding
  5. coda_h264_profile
  6. coda_h264_level
  7. rbsp_read_bit
  8. rbsp_write_bit
  9. rbsp_read_bits
  10. rbsp_write_bits
  11. rbsp_read_uev
  12. rbsp_write_uev
  13. rbsp_read_sev
  14. coda_h264_sps_fixup
   1 // SPDX-License-Identifier: GPL-2.0-or-later
   2 /*
   3  * Coda multi-standard codec IP - H.264 helper functions
   4  *
   5  * Copyright (C) 2012 Vista Silicon S.L.
   6  *    Javier Martin, <javier.martin@vista-silicon.com>
   7  *    Xavier Duret
   8  */
   9 
  10 #include <linux/kernel.h>
  11 #include <linux/string.h>
  12 #include <linux/videodev2.h>
  13 
  14 #include "coda.h"
  15 
  16 static const u8 coda_filler_size[8] = { 0, 7, 14, 13, 12, 11, 10, 9 };
  17 
  18 static const u8 *coda_find_nal_header(const u8 *buf, const u8 *end)
  19 {
  20         u32 val = 0xffffffff;
  21 
  22         do {
  23                 val = val << 8 | *buf++;
  24                 if (buf >= end)
  25                         return NULL;
  26         } while (val != 0x00000001);
  27 
  28         return buf;
  29 }
  30 
  31 int coda_sps_parse_profile(struct coda_ctx *ctx, struct vb2_buffer *vb)
  32 {
  33         const u8 *buf = vb2_plane_vaddr(vb, 0);
  34         const u8 *end = buf + vb2_get_plane_payload(vb, 0);
  35 
  36         /* Find SPS header */
  37         do {
  38                 buf = coda_find_nal_header(buf, end);
  39                 if (!buf)
  40                         return -EINVAL;
  41         } while ((*buf++ & 0x1f) != 0x7);
  42 
  43         ctx->params.h264_profile_idc = buf[0];
  44         ctx->params.h264_level_idc = buf[2];
  45 
  46         return 0;
  47 }
  48 
  49 int coda_h264_filler_nal(int size, char *p)
  50 {
  51         if (size < 6)
  52                 return -EINVAL;
  53 
  54         p[0] = 0x00;
  55         p[1] = 0x00;
  56         p[2] = 0x00;
  57         p[3] = 0x01;
  58         p[4] = 0x0c;
  59         memset(p + 5, 0xff, size - 6);
  60         /* Add rbsp stop bit and trailing at the end */
  61         p[size - 1] = 0x80;
  62 
  63         return 0;
  64 }
  65 
  66 int coda_h264_padding(int size, char *p)
  67 {
  68         int nal_size;
  69         int diff;
  70 
  71         diff = size - (size & ~0x7);
  72         if (diff == 0)
  73                 return 0;
  74 
  75         nal_size = coda_filler_size[diff];
  76         coda_h264_filler_nal(nal_size, p);
  77 
  78         return nal_size;
  79 }
  80 
  81 int coda_h264_profile(int profile_idc)
  82 {
  83         switch (profile_idc) {
  84         case 66: return V4L2_MPEG_VIDEO_H264_PROFILE_BASELINE;
  85         case 77: return V4L2_MPEG_VIDEO_H264_PROFILE_MAIN;
  86         case 88: return V4L2_MPEG_VIDEO_H264_PROFILE_EXTENDED;
  87         case 100: return V4L2_MPEG_VIDEO_H264_PROFILE_HIGH;
  88         default: return -EINVAL;
  89         }
  90 }
  91 
  92 int coda_h264_level(int level_idc)
  93 {
  94         switch (level_idc) {
  95         case 10: return V4L2_MPEG_VIDEO_H264_LEVEL_1_0;
  96         case 9:  return V4L2_MPEG_VIDEO_H264_LEVEL_1B;
  97         case 11: return V4L2_MPEG_VIDEO_H264_LEVEL_1_1;
  98         case 12: return V4L2_MPEG_VIDEO_H264_LEVEL_1_2;
  99         case 13: return V4L2_MPEG_VIDEO_H264_LEVEL_1_3;
 100         case 20: return V4L2_MPEG_VIDEO_H264_LEVEL_2_0;
 101         case 21: return V4L2_MPEG_VIDEO_H264_LEVEL_2_1;
 102         case 22: return V4L2_MPEG_VIDEO_H264_LEVEL_2_2;
 103         case 30: return V4L2_MPEG_VIDEO_H264_LEVEL_3_0;
 104         case 31: return V4L2_MPEG_VIDEO_H264_LEVEL_3_1;
 105         case 32: return V4L2_MPEG_VIDEO_H264_LEVEL_3_2;
 106         case 40: return V4L2_MPEG_VIDEO_H264_LEVEL_4_0;
 107         case 41: return V4L2_MPEG_VIDEO_H264_LEVEL_4_1;
 108         case 42: return V4L2_MPEG_VIDEO_H264_LEVEL_4_2;
 109         case 50: return V4L2_MPEG_VIDEO_H264_LEVEL_5_0;
 110         case 51: return V4L2_MPEG_VIDEO_H264_LEVEL_5_1;
 111         default: return -EINVAL;
 112         }
 113 }
 114 
 115 struct rbsp {
 116         char *buf;
 117         int size;
 118         int pos;
 119 };
 120 
 121 static inline int rbsp_read_bit(struct rbsp *rbsp)
 122 {
 123         int shift = 7 - (rbsp->pos % 8);
 124         int ofs = rbsp->pos++ / 8;
 125 
 126         if (ofs >= rbsp->size)
 127                 return -EINVAL;
 128 
 129         return (rbsp->buf[ofs] >> shift) & 1;
 130 }
 131 
 132 static inline int rbsp_write_bit(struct rbsp *rbsp, int bit)
 133 {
 134         int shift = 7 - (rbsp->pos % 8);
 135         int ofs = rbsp->pos++ / 8;
 136 
 137         if (ofs >= rbsp->size)
 138                 return -EINVAL;
 139 
 140         rbsp->buf[ofs] &= ~(1 << shift);
 141         rbsp->buf[ofs] |= bit << shift;
 142 
 143         return 0;
 144 }
 145 
 146 static inline int rbsp_read_bits(struct rbsp *rbsp, int num, int *val)
 147 {
 148         int i, ret;
 149         int tmp = 0;
 150 
 151         if (num > 32)
 152                 return -EINVAL;
 153 
 154         for (i = 0; i < num; i++) {
 155                 ret = rbsp_read_bit(rbsp);
 156                 if (ret < 0)
 157                         return ret;
 158                 tmp |= ret << (num - i - 1);
 159         }
 160 
 161         if (val)
 162                 *val = tmp;
 163 
 164         return 0;
 165 }
 166 
 167 static int rbsp_write_bits(struct rbsp *rbsp, int num, int value)
 168 {
 169         int ret;
 170 
 171         while (num--) {
 172                 ret = rbsp_write_bit(rbsp, (value >> num) & 1);
 173                 if (ret)
 174                         return ret;
 175         }
 176 
 177         return 0;
 178 }
 179 
 180 static int rbsp_read_uev(struct rbsp *rbsp, unsigned int *val)
 181 {
 182         int leading_zero_bits = 0;
 183         unsigned int tmp = 0;
 184         int ret;
 185 
 186         while ((ret = rbsp_read_bit(rbsp)) == 0)
 187                 leading_zero_bits++;
 188         if (ret < 0)
 189                 return ret;
 190 
 191         if (leading_zero_bits > 0) {
 192                 ret = rbsp_read_bits(rbsp, leading_zero_bits, &tmp);
 193                 if (ret)
 194                         return ret;
 195         }
 196 
 197         if (val)
 198                 *val = (1 << leading_zero_bits) - 1 + tmp;
 199 
 200         return 0;
 201 }
 202 
 203 static int rbsp_write_uev(struct rbsp *rbsp, unsigned int value)
 204 {
 205         int i;
 206         int ret;
 207         int tmp = value + 1;
 208         int leading_zero_bits = fls(tmp) - 1;
 209 
 210         for (i = 0; i < leading_zero_bits; i++) {
 211                 ret = rbsp_write_bit(rbsp, 0);
 212                 if (ret)
 213                         return ret;
 214         }
 215 
 216         return rbsp_write_bits(rbsp, leading_zero_bits + 1, tmp);
 217 }
 218 
 219 static int rbsp_read_sev(struct rbsp *rbsp, int *val)
 220 {
 221         unsigned int tmp;
 222         int ret;
 223 
 224         ret = rbsp_read_uev(rbsp, &tmp);
 225         if (ret)
 226                 return ret;
 227 
 228         if (val) {
 229                 if (tmp & 1)
 230                         *val = (tmp + 1) / 2;
 231                 else
 232                         *val = -(tmp / 2);
 233         }
 234 
 235         return 0;
 236 }
 237 
 238 /**
 239  * coda_h264_sps_fixup - fixes frame cropping values in h.264 SPS
 240  * @ctx: encoder context
 241  * @width: visible width
 242  * @height: visible height
 243  * @buf: buffer containing h.264 SPS RBSP, starting with NAL header
 244  * @size: modified RBSP size return value
 245  * @max_size: available size in buf
 246  *
 247  * Rewrites the frame cropping values in an h.264 SPS RBSP correctly for the
 248  * given visible width and height.
 249  */
 250 int coda_h264_sps_fixup(struct coda_ctx *ctx, int width, int height, char *buf,
 251                         int *size, int max_size)
 252 {
 253         int profile_idc;
 254         unsigned int pic_order_cnt_type;
 255         int pic_width_in_mbs_minus1, pic_height_in_map_units_minus1;
 256         int frame_mbs_only_flag, frame_cropping_flag;
 257         int vui_parameters_present_flag;
 258         unsigned int crop_right, crop_bottom;
 259         struct rbsp sps;
 260         int pos;
 261         int ret;
 262 
 263         if (*size < 8 || *size >= max_size)
 264                 return -EINVAL;
 265 
 266         sps.buf = buf + 5; /* Skip NAL header */
 267         sps.size = *size - 5;
 268 
 269         profile_idc = sps.buf[0];
 270         /* Skip constraint_set[0-5]_flag, reserved_zero_2bits */
 271         /* Skip level_idc */
 272         sps.pos = 24;
 273 
 274         /* seq_parameter_set_id */
 275         ret = rbsp_read_uev(&sps, NULL);
 276         if (ret)
 277                 return ret;
 278 
 279         if (profile_idc == 100 || profile_idc == 110 || profile_idc == 122 ||
 280             profile_idc == 244 || profile_idc == 44 || profile_idc == 83 ||
 281             profile_idc == 86 || profile_idc == 118 || profile_idc == 128 ||
 282             profile_idc == 138 || profile_idc == 139 || profile_idc == 134 ||
 283             profile_idc == 135) {
 284                 dev_err(ctx->fh.vdev->dev_parent,
 285                         "%s: Handling profile_idc %d not implemented\n",
 286                         __func__, profile_idc);
 287                 return -EINVAL;
 288         }
 289 
 290         /* log2_max_frame_num_minus4 */
 291         ret = rbsp_read_uev(&sps, NULL);
 292         if (ret)
 293                 return ret;
 294 
 295         ret = rbsp_read_uev(&sps, &pic_order_cnt_type);
 296         if (ret)
 297                 return ret;
 298 
 299         if (pic_order_cnt_type == 0) {
 300                 /* log2_max_pic_order_cnt_lsb_minus4 */
 301                 ret = rbsp_read_uev(&sps, NULL);
 302                 if (ret)
 303                         return ret;
 304         } else if (pic_order_cnt_type == 1) {
 305                 unsigned int i, num_ref_frames_in_pic_order_cnt_cycle;
 306 
 307                 /* delta_pic_order_always_zero_flag */
 308                 ret = rbsp_read_bit(&sps);
 309                 if (ret < 0)
 310                         return ret;
 311                 /* offset_for_non_ref_pic */
 312                 ret = rbsp_read_sev(&sps, NULL);
 313                 if (ret)
 314                         return ret;
 315                 /* offset_for_top_to_bottom_field */
 316                 ret = rbsp_read_sev(&sps, NULL);
 317                 if (ret)
 318                         return ret;
 319 
 320                 ret = rbsp_read_uev(&sps,
 321                                     &num_ref_frames_in_pic_order_cnt_cycle);
 322                 if (ret)
 323                         return ret;
 324                 for (i = 0; i < num_ref_frames_in_pic_order_cnt_cycle; i++) {
 325                         /* offset_for_ref_frame */
 326                         ret = rbsp_read_sev(&sps, NULL);
 327                         if (ret)
 328                                 return ret;
 329                 }
 330         }
 331 
 332         /* max_num_ref_frames */
 333         ret = rbsp_read_uev(&sps, NULL);
 334         if (ret)
 335                 return ret;
 336 
 337         /* gaps_in_frame_num_value_allowed_flag */
 338         ret = rbsp_read_bit(&sps);
 339         if (ret < 0)
 340                 return ret;
 341         ret = rbsp_read_uev(&sps, &pic_width_in_mbs_minus1);
 342         if (ret)
 343                 return ret;
 344         ret = rbsp_read_uev(&sps, &pic_height_in_map_units_minus1);
 345         if (ret)
 346                 return ret;
 347         frame_mbs_only_flag = ret = rbsp_read_bit(&sps);
 348         if (ret < 0)
 349                 return ret;
 350         if (!frame_mbs_only_flag) {
 351                 /* mb_adaptive_frame_field_flag */
 352                 ret = rbsp_read_bit(&sps);
 353                 if (ret < 0)
 354                         return ret;
 355         }
 356         /* direct_8x8_inference_flag */
 357         ret = rbsp_read_bit(&sps);
 358         if (ret < 0)
 359                 return ret;
 360 
 361         /* Mark position of the frame cropping flag */
 362         pos = sps.pos;
 363         frame_cropping_flag = ret = rbsp_read_bit(&sps);
 364         if (ret < 0)
 365                 return ret;
 366         if (frame_cropping_flag) {
 367                 unsigned int crop_left, crop_top;
 368 
 369                 ret = rbsp_read_uev(&sps, &crop_left);
 370                 if (ret)
 371                         return ret;
 372                 ret = rbsp_read_uev(&sps, &crop_right);
 373                 if (ret)
 374                         return ret;
 375                 ret = rbsp_read_uev(&sps, &crop_top);
 376                 if (ret)
 377                         return ret;
 378                 ret = rbsp_read_uev(&sps, &crop_bottom);
 379                 if (ret)
 380                         return ret;
 381         }
 382         vui_parameters_present_flag = ret = rbsp_read_bit(&sps);
 383         if (ret < 0)
 384                 return ret;
 385         if (vui_parameters_present_flag) {
 386                 dev_err(ctx->fh.vdev->dev_parent,
 387                         "%s: Handling vui_parameters not implemented\n",
 388                         __func__);
 389                 return -EINVAL;
 390         }
 391 
 392         crop_right = round_up(width, 16) - width;
 393         crop_bottom = round_up(height, 16) - height;
 394         crop_right /= 2;
 395         if (frame_mbs_only_flag)
 396                 crop_bottom /= 2;
 397         else
 398                 crop_bottom /= 4;
 399 
 400 
 401         sps.size = max_size - 5;
 402         sps.pos = pos;
 403         frame_cropping_flag = 1;
 404         ret = rbsp_write_bit(&sps, frame_cropping_flag);
 405         if (ret)
 406                 return ret;
 407         ret = rbsp_write_uev(&sps, 0); /* crop_left */
 408         if (ret)
 409                 return ret;
 410         ret = rbsp_write_uev(&sps, crop_right);
 411         if (ret)
 412                 return ret;
 413         ret = rbsp_write_uev(&sps, 0); /* crop_top */
 414         if (ret)
 415                 return ret;
 416         ret = rbsp_write_uev(&sps, crop_bottom);
 417         if (ret)
 418                 return ret;
 419         ret = rbsp_write_bit(&sps, 0); /* vui_parameters_present_flag */
 420         if (ret)
 421                 return ret;
 422         ret = rbsp_write_bit(&sps, 1);
 423         if (ret)
 424                 return ret;
 425 
 426         *size = 5 + DIV_ROUND_UP(sps.pos, 8);
 427 
 428         return 0;
 429 }
/* [<][>][^][v][top][bottom][index][help] */