Lines Matching refs:frame
56 * @frame: HDMI AVI infoframe
58 void hdmi_avi_infoframe_init(struct hdmi_avi_infoframe *frame)
60 memset(frame, 0, sizeof(*frame));
62 frame->type = HDMI_INFOFRAME_TYPE_AVI;
63 frame->version = 2;
64 frame->length = HDMI_AVI_INFOFRAME_SIZE;
68 static int hdmi_avi_infoframe_check_only(const struct hdmi_avi_infoframe *frame)
70 if (frame->type != HDMI_INFOFRAME_TYPE_AVI ||
71 frame->version != 2 ||
72 frame->length != HDMI_AVI_INFOFRAME_SIZE)
75 if (frame->picture_aspect > HDMI_PICTURE_ASPECT_16_9)
83 * @frame: HDMI AVI infoframe
90 int hdmi_avi_infoframe_check(struct hdmi_avi_infoframe *frame)
92 return hdmi_avi_infoframe_check_only(frame);
98 * @frame: HDMI AVI infoframe
102 * Packs the information contained in the @frame structure into a binary
110 ssize_t hdmi_avi_infoframe_pack_only(const struct hdmi_avi_infoframe *frame,
117 ret = hdmi_avi_infoframe_check_only(frame);
121 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
128 ptr[0] = frame->type;
129 ptr[1] = frame->version;
130 ptr[2] = frame->length;
136 ptr[0] = ((frame->colorspace & 0x3) << 5) | (frame->scan_mode & 0x3);
142 if (frame->active_aspect & 0xf)
146 if (frame->top_bar || frame->bottom_bar)
149 if (frame->left_bar || frame->right_bar)
152 ptr[1] = ((frame->colorimetry & 0x3) << 6) |
153 ((frame->picture_aspect & 0x3) << 4) |
154 (frame->active_aspect & 0xf);
156 ptr[2] = ((frame->extended_colorimetry & 0x7) << 4) |
157 ((frame->quantization_range & 0x3) << 2) |
158 (frame->nups & 0x3);
160 if (frame->itc)
163 ptr[3] = frame->video_code & 0x7f;
165 ptr[4] = ((frame->ycc_quantization_range & 0x3) << 6) |
166 ((frame->content_type & 0x3) << 4) |
167 (frame->pixel_repeat & 0xf);
169 ptr[5] = frame->top_bar & 0xff;
170 ptr[6] = (frame->top_bar >> 8) & 0xff;
171 ptr[7] = frame->bottom_bar & 0xff;
172 ptr[8] = (frame->bottom_bar >> 8) & 0xff;
173 ptr[9] = frame->left_bar & 0xff;
174 ptr[10] = (frame->left_bar >> 8) & 0xff;
175 ptr[11] = frame->right_bar & 0xff;
176 ptr[12] = (frame->right_bar >> 8) & 0xff;
187 * @frame: HDMI AVI infoframe
193 * contained in the @frame structure into a binary representation that
201 ssize_t hdmi_avi_infoframe_pack(struct hdmi_avi_infoframe *frame,
206 ret = hdmi_avi_infoframe_check(frame);
210 return hdmi_avi_infoframe_pack_only(frame, buffer, size);
216 * @frame: HDMI SPD infoframe
222 int hdmi_spd_infoframe_init(struct hdmi_spd_infoframe *frame,
227 memset(frame, 0, sizeof(*frame));
229 frame->type = HDMI_INFOFRAME_TYPE_SPD;
230 frame->version = 1;
231 frame->length = HDMI_SPD_INFOFRAME_SIZE;
234 memcpy(frame->vendor, vendor, min(len, sizeof(frame->vendor)));
236 memcpy(frame->product, product, min(len, sizeof(frame->product)));
242 static int hdmi_spd_infoframe_check_only(const struct hdmi_spd_infoframe *frame)
244 if (frame->type != HDMI_INFOFRAME_TYPE_SPD ||
245 frame->version != 1 ||
246 frame->length != HDMI_SPD_INFOFRAME_SIZE)
254 * @frame: HDMI SPD infoframe
261 int hdmi_spd_infoframe_check(struct hdmi_spd_infoframe *frame)
263 return hdmi_spd_infoframe_check_only(frame);
269 * @frame: HDMI SPD infoframe
273 * Packs the information contained in the @frame structure into a binary
281 ssize_t hdmi_spd_infoframe_pack_only(const struct hdmi_spd_infoframe *frame,
288 ret = hdmi_spd_infoframe_check_only(frame);
292 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
299 ptr[0] = frame->type;
300 ptr[1] = frame->version;
301 ptr[2] = frame->length;
307 memcpy(ptr, frame->vendor, sizeof(frame->vendor));
308 memcpy(ptr + 8, frame->product, sizeof(frame->product));
310 ptr[24] = frame->sdi;
321 * @frame: HDMI SPD infoframe
327 * contained in the @frame structure into a binary representation that
335 ssize_t hdmi_spd_infoframe_pack(struct hdmi_spd_infoframe *frame,
340 ret = hdmi_spd_infoframe_check(frame);
344 return hdmi_spd_infoframe_pack_only(frame, buffer, size);
350 * @frame: HDMI audio infoframe
354 int hdmi_audio_infoframe_init(struct hdmi_audio_infoframe *frame)
356 memset(frame, 0, sizeof(*frame));
358 frame->type = HDMI_INFOFRAME_TYPE_AUDIO;
359 frame->version = 1;
360 frame->length = HDMI_AUDIO_INFOFRAME_SIZE;
366 static int hdmi_audio_infoframe_check_only(const struct hdmi_audio_infoframe *frame)
368 if (frame->type != HDMI_INFOFRAME_TYPE_AUDIO ||
369 frame->version != 1 ||
370 frame->length != HDMI_AUDIO_INFOFRAME_SIZE)
378 * @frame: HDMI audio infoframe
385 int hdmi_audio_infoframe_check(const struct hdmi_audio_infoframe *frame)
387 return hdmi_audio_infoframe_check_only(frame);
392 hdmi_audio_infoframe_pack_payload(const struct hdmi_audio_infoframe *frame,
397 if (frame->channels >= 2)
398 channels = frame->channels - 1;
402 buffer[0] = ((frame->coding_type & 0xf) << 4) | (channels & 0x7);
403 buffer[1] = ((frame->sample_frequency & 0x7) << 2) |
404 (frame->sample_size & 0x3);
405 buffer[2] = frame->coding_type_ext & 0x1f;
406 buffer[3] = frame->channel_allocation;
407 buffer[4] = (frame->level_shift_value & 0xf) << 3;
409 if (frame->downmix_inhibit)
415 * @frame: HDMI audio infoframe
419 * Packs the information contained in the @frame structure into a binary
427 ssize_t hdmi_audio_infoframe_pack_only(const struct hdmi_audio_infoframe *frame,
434 ret = hdmi_audio_infoframe_check_only(frame);
438 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
445 ptr[0] = frame->type;
446 ptr[1] = frame->version;
447 ptr[2] = frame->length;
450 hdmi_audio_infoframe_pack_payload(frame,
462 * @frame: HDMI Audio infoframe
468 * contained in the @frame structure into a binary representation that
476 ssize_t hdmi_audio_infoframe_pack(struct hdmi_audio_infoframe *frame,
481 ret = hdmi_audio_infoframe_check(frame);
485 return hdmi_audio_infoframe_pack_only(frame, buffer, size);
492 * @frame: HDMI Audio infoframe
502 hdmi_audio_infoframe_pack_for_dp(const struct hdmi_audio_infoframe *frame,
507 ret = hdmi_audio_infoframe_check(frame);
515 sdp->sdp_header.HB1 = frame->type;
519 hdmi_audio_infoframe_pack_payload(frame, sdp->db);
521 /* Return size = frame length + four HB for sdp_header */
522 return frame->length + 4;
528 * @frame: HDMI vendor infoframe
532 int hdmi_vendor_infoframe_init(struct hdmi_vendor_infoframe *frame)
534 memset(frame, 0, sizeof(*frame));
536 frame->type = HDMI_INFOFRAME_TYPE_VENDOR;
537 frame->version = 1;
539 frame->oui = HDMI_IEEE_OUI;
545 frame->s3d_struct = HDMI_3D_STRUCTURE_INVALID;
546 frame->length = HDMI_VENDOR_INFOFRAME_SIZE;
552 static int hdmi_vendor_infoframe_length(const struct hdmi_vendor_infoframe *frame)
555 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
557 else if (frame->vic != 0 || frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
563 static int hdmi_vendor_infoframe_check_only(const struct hdmi_vendor_infoframe *frame)
565 if (frame->type != HDMI_INFOFRAME_TYPE_VENDOR ||
566 frame->version != 1 ||
567 frame->oui != HDMI_IEEE_OUI)
571 if (frame->vic != 0 && frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID)
574 if (frame->length != hdmi_vendor_infoframe_length(frame))
582 * @frame: HDMI infoframe
589 int hdmi_vendor_infoframe_check(struct hdmi_vendor_infoframe *frame)
591 frame->length = hdmi_vendor_infoframe_length(frame);
593 return hdmi_vendor_infoframe_check_only(frame);
599 * @frame: HDMI infoframe
603 * Packs the information contained in the @frame structure into a binary
611 ssize_t hdmi_vendor_infoframe_pack_only(const struct hdmi_vendor_infoframe *frame,
618 ret = hdmi_vendor_infoframe_check_only(frame);
622 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
629 ptr[0] = frame->type;
630 ptr[1] = frame->version;
631 ptr[2] = frame->length;
639 if (frame->s3d_struct != HDMI_3D_STRUCTURE_INVALID) {
641 ptr[8] = (frame->s3d_struct & 0xf) << 4;
642 if (frame->s3d_struct >= HDMI_3D_STRUCTURE_SIDE_BY_SIDE_HALF)
643 ptr[9] = (frame->s3d_ext_data & 0xf) << 4;
644 } else if (frame->vic) {
646 ptr[8] = frame->vic;
660 * @frame: HDMI Vendor infoframe
666 * contained in the @frame structure into a binary representation that
674 ssize_t hdmi_vendor_infoframe_pack(struct hdmi_vendor_infoframe *frame,
679 ret = hdmi_vendor_infoframe_check(frame);
683 return hdmi_vendor_infoframe_pack_only(frame, buffer, size);
688 hdmi_vendor_any_infoframe_check_only(const union hdmi_vendor_any_infoframe *frame)
690 if (frame->any.type != HDMI_INFOFRAME_TYPE_VENDOR ||
691 frame->any.version != 1)
700 * @frame: HDMI DRM infoframe
704 int hdmi_drm_infoframe_init(struct hdmi_drm_infoframe *frame)
706 memset(frame, 0, sizeof(*frame));
708 frame->type = HDMI_INFOFRAME_TYPE_DRM;
709 frame->version = 1;
710 frame->length = HDMI_DRM_INFOFRAME_SIZE;
716 static int hdmi_drm_infoframe_check_only(const struct hdmi_drm_infoframe *frame)
718 if (frame->type != HDMI_INFOFRAME_TYPE_DRM ||
719 frame->version != 1)
722 if (frame->length != HDMI_DRM_INFOFRAME_SIZE)
730 * @frame: HDMI DRM infoframe
735 int hdmi_drm_infoframe_check(struct hdmi_drm_infoframe *frame)
737 return hdmi_drm_infoframe_check_only(frame);
743 * @frame: HDMI DRM infoframe
747 * Packs the information contained in the @frame structure into a binary
755 ssize_t hdmi_drm_infoframe_pack_only(const struct hdmi_drm_infoframe *frame,
762 length = HDMI_INFOFRAME_HEADER_SIZE + frame->length;
769 ptr[0] = frame->type;
770 ptr[1] = frame->version;
771 ptr[2] = frame->length;
777 *ptr++ = frame->eotf;
778 *ptr++ = frame->metadata_type;
781 *ptr++ = frame->display_primaries[i].x;
782 *ptr++ = frame->display_primaries[i].x >> 8;
783 *ptr++ = frame->display_primaries[i].y;
784 *ptr++ = frame->display_primaries[i].y >> 8;
787 *ptr++ = frame->white_point.x;
788 *ptr++ = frame->white_point.x >> 8;
790 *ptr++ = frame->white_point.y;
791 *ptr++ = frame->white_point.y >> 8;
793 *ptr++ = frame->max_display_mastering_luminance;
794 *ptr++ = frame->max_display_mastering_luminance >> 8;
796 *ptr++ = frame->min_display_mastering_luminance;
797 *ptr++ = frame->min_display_mastering_luminance >> 8;
799 *ptr++ = frame->max_cll;
800 *ptr++ = frame->max_cll >> 8;
802 *ptr++ = frame->max_fall;
803 *ptr++ = frame->max_fall >> 8;
814 * @frame: HDMI DRM infoframe
820 * contained in the @frame structure into a binary representation that
828 ssize_t hdmi_drm_infoframe_pack(struct hdmi_drm_infoframe *frame,
833 ret = hdmi_drm_infoframe_check(frame);
837 return hdmi_drm_infoframe_pack_only(frame, buffer, size);
845 hdmi_vendor_any_infoframe_check(union hdmi_vendor_any_infoframe *frame)
849 ret = hdmi_vendor_any_infoframe_check_only(frame);
854 if (frame->any.oui != HDMI_IEEE_OUI)
857 return hdmi_vendor_infoframe_check(&frame->hdmi);
864 hdmi_vendor_any_infoframe_pack_only(const union hdmi_vendor_any_infoframe *frame,
869 ret = hdmi_vendor_any_infoframe_check_only(frame);
874 if (frame->any.oui != HDMI_IEEE_OUI)
877 return hdmi_vendor_infoframe_pack_only(&frame->hdmi, buffer, size);
885 hdmi_vendor_any_infoframe_pack(union hdmi_vendor_any_infoframe *frame,
890 ret = hdmi_vendor_any_infoframe_check(frame);
894 return hdmi_vendor_any_infoframe_pack_only(frame, buffer, size);
899 * @frame: HDMI infoframe
907 hdmi_infoframe_check(union hdmi_infoframe *frame)
909 switch (frame->any.type) {
911 return hdmi_avi_infoframe_check(&frame->avi);
913 return hdmi_spd_infoframe_check(&frame->spd);
915 return hdmi_audio_infoframe_check(&frame->audio);
917 return hdmi_vendor_any_infoframe_check(&frame->vendor);
919 WARN(1, "Bad infoframe type %d\n", frame->any.type);
927 * @frame: HDMI infoframe
931 * Packs the information contained in the @frame structure into a binary
940 hdmi_infoframe_pack_only(const union hdmi_infoframe *frame, void *buffer, size_t size)
944 switch (frame->any.type) {
946 length = hdmi_avi_infoframe_pack_only(&frame->avi,
950 length = hdmi_drm_infoframe_pack_only(&frame->drm,
954 length = hdmi_spd_infoframe_pack_only(&frame->spd,
958 length = hdmi_audio_infoframe_pack_only(&frame->audio,
962 length = hdmi_vendor_any_infoframe_pack_only(&frame->vendor,
966 WARN(1, "Bad infoframe type %d\n", frame->any.type);
977 * @frame: HDMI infoframe
983 * contained in the @frame structure into a binary representation that
992 hdmi_infoframe_pack(union hdmi_infoframe *frame,
997 switch (frame->any.type) {
999 length = hdmi_avi_infoframe_pack(&frame->avi, buffer, size);
1002 length = hdmi_drm_infoframe_pack(&frame->drm, buffer, size);
1005 length = hdmi_spd_infoframe_pack(&frame->spd, buffer, size);
1008 length = hdmi_audio_infoframe_pack(&frame->audio, buffer, size);
1011 length = hdmi_vendor_any_infoframe_pack(&frame->vendor,
1015 WARN(1, "Bad infoframe type %d\n", frame->any.type);
1044 const struct hdmi_any_infoframe *frame)
1047 hdmi_infoframe_type_get_name(frame->type),
1048 frame->version, frame->length);
1240 const struct hdmi_avi_infoframe *frame)
1243 (const struct hdmi_any_infoframe *)frame);
1246 hdmi_colorspace_get_name(frame->colorspace));
1248 hdmi_scan_mode_get_name(frame->scan_mode));
1250 hdmi_colorimetry_get_name(frame->colorimetry));
1252 hdmi_picture_aspect_get_name(frame->picture_aspect));
1254 hdmi_active_aspect_get_name(frame->active_aspect));
1255 hdmi_log(" itc: %s\n", frame->itc ? "IT Content" : "No Data");
1257 hdmi_extended_colorimetry_get_name(frame->extended_colorimetry));
1259 hdmi_quantization_range_get_name(frame->quantization_range));
1260 hdmi_log(" nups: %s\n", hdmi_nups_get_name(frame->nups));
1261 hdmi_log(" video code: %u\n", frame->video_code);
1263 hdmi_ycc_quantization_range_get_name(frame->ycc_quantization_range));
1265 hdmi_content_type_get_name(frame->content_type));
1266 hdmi_log(" pixel repeat: %u\n", frame->pixel_repeat);
1268 frame->top_bar, frame->bottom_bar,
1269 frame->left_bar, frame->right_bar);
1311 const struct hdmi_spd_infoframe *frame)
1316 (const struct hdmi_any_infoframe *)frame);
1320 strncpy(buf, frame->vendor, 8);
1322 strncpy(buf, frame->product, 16);
1325 hdmi_spd_sdi_get_name(frame->sdi), frame->sdi);
1441 const struct hdmi_audio_infoframe *frame)
1444 (const struct hdmi_any_infoframe *)frame);
1446 if (frame->channels)
1447 hdmi_log(" channels: %u\n", frame->channels - 1);
1451 hdmi_audio_coding_type_get_name(frame->coding_type));
1453 hdmi_audio_sample_size_get_name(frame->sample_size));
1455 hdmi_audio_sample_frequency_get_name(frame->sample_frequency));
1457 hdmi_audio_coding_type_ext_get_name(frame->coding_type_ext));
1459 frame->channel_allocation);
1461 frame->level_shift_value);
1463 frame->downmix_inhibit ? "Yes" : "No");
1468 const struct hdmi_drm_infoframe *frame)
1473 (struct hdmi_any_infoframe *)frame);
1474 hdmi_log("length: %d\n", frame->length);
1475 hdmi_log("metadata type: %d\n", frame->metadata_type);
1476 hdmi_log("eotf: %d\n", frame->eotf);
1478 hdmi_log("x[%d]: %d\n", i, frame->display_primaries[i].x);
1479 hdmi_log("y[%d]: %d\n", i, frame->display_primaries[i].y);
1482 hdmi_log("white point x: %d\n", frame->white_point.x);
1483 hdmi_log("white point y: %d\n", frame->white_point.y);
1486 frame->max_display_mastering_luminance);
1488 frame->min_display_mastering_luminance);
1490 hdmi_log("max_cll: %d\n", frame->max_cll);
1491 hdmi_log("max_fall: %d\n", frame->max_fall);
1526 const union hdmi_vendor_any_infoframe *frame)
1528 const struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1531 (const struct hdmi_any_infoframe *)frame);
1533 if (frame->any.oui != HDMI_IEEE_OUI) {
1538 hdmi_log(" empty frame\n");
1557 * @frame: HDMI infoframe
1561 const union hdmi_infoframe *frame)
1563 switch (frame->any.type) {
1565 hdmi_avi_infoframe_log(level, dev, &frame->avi);
1568 hdmi_spd_infoframe_log(level, dev, &frame->spd);
1571 hdmi_audio_infoframe_log(level, dev, &frame->audio);
1574 hdmi_vendor_any_infoframe_log(level, dev, &frame->vendor);
1577 hdmi_drm_infoframe_log(level, dev, &frame->drm);
1585 * @frame: HDMI AVI infoframe
1590 * @frame of the HDMI Auxiliary Video (AVI) information frame.
1596 static int hdmi_avi_infoframe_unpack(struct hdmi_avi_infoframe *frame,
1612 hdmi_avi_infoframe_init(frame);
1616 frame->colorspace = (ptr[0] >> 5) & 0x3;
1618 frame->active_aspect = ptr[1] & 0xf;
1620 frame->top_bar = (ptr[6] << 8) | ptr[5];
1621 frame->bottom_bar = (ptr[8] << 8) | ptr[7];
1624 frame->left_bar = (ptr[10] << 8) | ptr[9];
1625 frame->right_bar = (ptr[12] << 8) | ptr[11];
1627 frame->scan_mode = ptr[0] & 0x3;
1629 frame->colorimetry = (ptr[1] >> 6) & 0x3;
1630 frame->picture_aspect = (ptr[1] >> 4) & 0x3;
1631 frame->active_aspect = ptr[1] & 0xf;
1633 frame->itc = ptr[2] & 0x80 ? true : false;
1634 frame->extended_colorimetry = (ptr[2] >> 4) & 0x7;
1635 frame->quantization_range = (ptr[2] >> 2) & 0x3;
1636 frame->nups = ptr[2] & 0x3;
1638 frame->video_code = ptr[3] & 0x7f;
1639 frame->ycc_quantization_range = (ptr[4] >> 6) & 0x3;
1640 frame->content_type = (ptr[4] >> 4) & 0x3;
1642 frame->pixel_repeat = ptr[4] & 0xf;
1649 * @frame: HDMI SPD infoframe
1654 * @frame of the HDMI Source Product Description (SPD) information frame.
1660 static int hdmi_spd_infoframe_unpack(struct hdmi_spd_infoframe *frame,
1680 ret = hdmi_spd_infoframe_init(frame, ptr, ptr + 8);
1684 frame->sdi = ptr[24];
1691 * @frame: HDMI Audio infoframe
1696 * @frame of the HDMI Audio information frame.
1702 static int hdmi_audio_infoframe_unpack(struct hdmi_audio_infoframe *frame,
1720 ret = hdmi_audio_infoframe_init(frame);
1726 frame->channels = ptr[0] & 0x7;
1727 frame->coding_type = (ptr[0] >> 4) & 0xf;
1728 frame->sample_size = ptr[1] & 0x3;
1729 frame->sample_frequency = (ptr[1] >> 2) & 0x7;
1730 frame->coding_type_ext = ptr[2] & 0x1f;
1731 frame->channel_allocation = ptr[3];
1732 frame->level_shift_value = (ptr[4] >> 3) & 0xf;
1733 frame->downmix_inhibit = ptr[4] & 0x80 ? true : false;
1741 * @frame: HDMI Vendor infoframe
1746 * @frame of the HDMI Vendor information frame.
1753 hdmi_vendor_any_infoframe_unpack(union hdmi_vendor_any_infoframe *frame,
1760 struct hdmi_vendor_infoframe *hvf = &frame->hdmi;
1823 * @frame: HDMI DRM infoframe
1828 * into a structured @frame of the HDMI Dynamic Range and Mastering (DRM)
1833 int hdmi_drm_infoframe_unpack_only(struct hdmi_drm_infoframe *frame,
1846 ret = hdmi_drm_infoframe_init(frame);
1850 frame->eotf = ptr[0] & 0x7;
1851 frame->metadata_type = ptr[1] & 0x7;
1857 frame->display_primaries[i].x = (x_msb << 8) | x_lsb;
1860 frame->display_primaries[i].y = (y_msb << 8) | y_lsb;
1863 frame->white_point.x = (ptr[15] << 8) | ptr[14];
1864 frame->white_point.y = (ptr[17] << 8) | ptr[16];
1866 frame->max_display_mastering_luminance = (ptr[19] << 8) | ptr[18];
1867 frame->min_display_mastering_luminance = (ptr[21] << 8) | ptr[20];
1868 frame->max_cll = (ptr[23] << 8) | ptr[22];
1869 frame->max_fall = (ptr[25] << 8) | ptr[24];
1877 * @frame: HDMI DRM infoframe
1882 * a structured @frame of the HDMI Dynamic Range and Mastering (DRM)
1888 static int hdmi_drm_infoframe_unpack(struct hdmi_drm_infoframe *frame,
1905 ret = hdmi_drm_infoframe_unpack_only(frame, ptr + HDMI_INFOFRAME_HEADER_SIZE,
1912 * @frame: HDMI infoframe
1917 * @frame of a HDMI infoframe.
1923 int hdmi_infoframe_unpack(union hdmi_infoframe *frame,
1934 ret = hdmi_avi_infoframe_unpack(&frame->avi, buffer, size);
1937 ret = hdmi_drm_infoframe_unpack(&frame->drm, buffer, size);
1940 ret = hdmi_spd_infoframe_unpack(&frame->spd, buffer, size);
1943 ret = hdmi_audio_infoframe_unpack(&frame->audio, buffer, size);
1946 ret = hdmi_vendor_any_infoframe_unpack(&frame->vendor, buffer, size);