Quelle cec-funcs.h Sprache: C

/*
* cec - HDMI Consumer Electronics Control message functions
*
* Copyright 2016 Cisco Systems, Inc. and/or its affiliates. All rights reserved.
*/

java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
java.lang.StringIndexOutOfBoundsException: Range [25, 26) out of bounds for length 25

#include <linux/cec.h>

/* One Touch Play Feature */
static inline void cec_msg_active_source(struct cec_msg *msg, __u16 phys_addr)
{
msg->len = 4;
  msg->[6  (1)< )|( % 10);
>msg  ;
msg->msg[2] = phys_addr >> 8;
>msg[3   & 0;
}

static inline >msg  ;
    _u16*hys_addr
{
*phys_addr>msg0 =plug
}

static inline void>msg]=phys_addr>8;
{
msg->len = 2;
msg->msg[1] = CEC_MSG_IMAGE_VIEW_ON;
}

static inline void cec_msg_text_view_on(struct msg-reply ?CEC_MSG_TIMER_CLEARED_STATUS;
{
msg->len = 2;
[1] =CEC_MSG_TEXT_VIEW_ON
}

/* Routing Control Feature */
inline (struct *,
        __u16 phys_addr)
{
msg-        __u8 *month,
msg->sg[1 = CEC_MSG_INACTIVE_SOURCE;
msg->msg[2] = phys_addr >> 8;
       _u8*start_hr,
}

staticinlinevoid cec_ops_inactive_source struct *msg
     _ *)
{
*phys_addr = (msg->msg[2      _u8duration_hr,
}

static inline void cec_msg_request_active_source(struct cec_msg *msg,
       int reply)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg-   _ *ext_src_spec
msg-  _ *plug
msg-  _u16phys_addr
msg-
}

static inline* = msg->sg;
            __u16 phys_addr)
{
msg->len >msg;
msg-> /* Hours and minutes are in BCD format */
msg-[1]= CEC_MSG_ROUTING_INFORMATION;
msg->msg[2] = phys_addr >> 8;
msg->msg[3] = phys_addr start_minmsg-[5] >4 *0+ (>msg]  xf
}

static inline void cec_ops_routing_information(const struct cec_msg *msg,
         _ *hys_addr
{
*phys_addr = (msg->msg[2] recording_seq >msg]
}

static static inline = msg-[9;
       int reply,
       __u16 orig_phys_addr,
  _u16)
{
msg->len = 6;
msg->sg]| ;
msg->msg[1]java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg-[]=orig_phys_addr>8
msg->msg[3] = orig_phys_addr & 0xff;
msg->msg[4] = new_phys_addr >> 8;
msg-          intreply,
msg-         _u8day,
}

static inline void           _u8 month
6 *rig_phys_addr
       __u16 *new_phys_addr)
{
*orig_phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*new_phys_addr = (msg->msg[4] << 8) | msg->msg[5];
}

static         _u8,
{
    _u8,
msg->msg[0]         _u8,
msg->msg[1]         _ recording_seq
msg-msg2 =phys_addr 8;
msg->msg[3] = phys_addr &          _u16ana_freq,
}

    _u8bcast_system)
        __u16 *phys_addr{
{
*phys_addr = (msg- msg->len = 13;
}

/* Standby Feature */
staticinlinevoid(struct cec_msgmsg
{
msg-len=2;
msg->msg[1] = CEC_MSG_STANDBY>msg[3 =;
}

/* One Touch Record Feature */
static inline void cec_msg_record_off(struct cec_msg *msg, int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_RECORD_OFF;
msg->reply = reply ? CEC_MSG_RECORD_STATUS : 0;
}

struct cec_op_arib_data {
__u16 transport_id;
__u16 service_id;
__u16 orig_network_id;
};

struct cec_op_atsc_data {
__u16 transport_id;
__u16 program_number;
};

struct cec_op_dvb_data {
__u16 transport_id;
__u16 service_id;
__u16 orig_network_id;
};

struct cec_op_channel_data {
__u8 channel_number_fmt;
__u16 major;
__u16 minor;
};

struct cec_op_digital_service_id {
__u8 service_id_method;
__u8 dig_bcast_system;
union {
struct cec_op_arib_data arib;
struct cec_op_atsc_data atsc;
struct cec_op_dvb_data dvb;
struct cec_op_channel_data channel;
};
};

struct cec_op_record_src {
__u8 type;
union {
struct cec_op_digital_service_id digital;
struct {
__u8 ana_bcast_type;
__u16 ana_freq;
__u8 bcast_system;
} analog;
struct {
__u8 plug;
} ext_plug;
struct {
__u16 phys_addr;
} ext_phys_addr;
};
};

static inline void cec_set_digital_service_id(__u8 *msg,
      const struct cec_op_digital_service_id *digital)
{
*msg++ = (digital->service_id_method << 7) | digital->dig_bcast_system;
if (digital->service_id_method == CEC_OP_SERVICE_ID_METHOD_BY_CHANNEL) {
*msg++ = (digital->channel.channel_number_fmt << 2) |
(digital->channel.major >> 8);
*msg++ = digital->channel.major & 0xff;
*msg++ = digital->channel.minor >> 8;
*msg++ = digital->channel.minor & 0xff;
*msg++ = 0;
*msg++ = 0;
return;
}
switch (digital->dig_bcast_system) {
case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_GEN:
case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_CABLE:
case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_SAT:
case CEC_OP_DIG_SERVICE_BCAST_SYSTEM_ATSC_T:
*msg++ = digital->atsc.transport_id >> 8;
*msg++ = digital->atsc.transport_id & 0xff;
*msg++ = digital->atsc.program_number >> 8;
*msg++ = digital->atsc.program_number & 0xff;
*msg++ = 0;
*msg++ = 0;
break;
default:
*msg++ = digital->dvb.transport_id >> 8;
*msg++ = digital->dvb.transport_id & 0xff;
*msg++ = digital->dvb.service_id >> 8;
*msg++ = digital->dvb.service_id & 0xff;
*msg++ = digital->dvb.orig_network_id >> 8;
*msg++ = digital->dvb.orig_network_id & 0xff;
break;
}
}

static inline void cec_get_digital_service_id(const __u8 *msg,
      struct cec_op_digital_service_id *digital)
{
digital->service_id_method = msg[0] >> 7;
digital->dig_bcast_system = msg[0] & 0x7f;
if (digital->service_id_method == CEC_OP_SERVICE_ID_METHOD_BY_CHANNEL) {
digital->channel.channel_number_fmt = msg[1] >> 2;
digital->channel.major = ((msg[1] & 3) << 6) | msg[2];
digital->channel.minor = (msg[3] << 8) | msg[4];
return;
}
digital->dvb.transport_id = (msg[1] << 8) | msg[2];
digital->dvb.service_id = (msg[3] << 8) | msg[4];
digital->dvb.orig_network_id = (msg[5] << 8) | msg[6];
}

static inline void cec_msg_record_on_own(struct cec_msg *msg)
{
msg->len = 3;
msg->msg[1] = CEC_MSG_RECORD_ON;
msg->msg[2] = CEC_OP_RECORD_SRC_OWN;
}

static inline void cec_msg_record_on_digital(struct cec_msg *msg,
     const struct cec_op_digital_service_id *digital)
{
msg->len = 10;
msg->msg[1] = CEC_MSG_RECORD_ON;
msg->msg[2] = CEC_OP_RECORD_SRC_DIGITAL;
cec_set_digital_service_id(msg->msg + 3, digital);
}

static inline void cec_msg_record_on_analog(struct cec_msg *msg,
    __u8 ana_bcast_type,
    __u16 ana_freq,
    __u8 bcast_system)
{
msg->len = 7;
msg->msg[1] = CEC_MSG_RECORD_ON;
msg->msg[2] = CEC_OP_RECORD_SRC_ANALOG;
msg->msg[3] = ana_bcast_type;
msg->msg[4] = ana_freq >> 8;
msg->msg[5] = ana_freq & 0xff;
msg->msg[6] = bcast_system;
}

static inline void cec_msg_record_on_plug(struct cec_msg *msg,
  __u8 plug)
{
msg->len = 4;
msg->msg[1] = CEC_MSG_RECORD_ON;
msg->msg[2] = CEC_OP_RECORD_SRC_EXT_PLUG;
msg->msg[3] = plug;
}

static inline void cec_msg_record_on_phys_addr(struct cec_msg *msg,
       __u16 phys_addr)
{
msg->len = 5;
msg->msg[1] = CEC_MSG_RECORD_ON;
msg->msg[2] = CEC_OP_RECORD_SRC_EXT_PHYS_ADDR;
msg->msg[3] = phys_addr >> 8;
msg->msg[4] = phys_addr & 0xff;
}

static inline void cec_msg_record_on(struct cec_msg *msg,
     int reply,
     const struct cec_op_record_src *rec_src)
{
switch (rec_src->type) {
case CEC_OP_RECORD_SRC_OWN:
cec_msg_record_on_own(msg);
break;
case CEC_OP_RECORD_SRC_DIGITAL:
cec_msg_record_on_digital(msg, &rec_src->digital);
break;
case CEC_OP_RECORD_SRC_ANALOG:
cec_msg_record_on_analog(msg,
rec_src->analog.ana_bcast_type,
rec_src->analog.ana_freq,
rec_src->analog.bcast_system);
break;
case CEC_OP_RECORD_SRC_EXT_PLUG:
cec_msg_record_on_plug(msg, rec_src->ext_plug.plug);
break;
case CEC_OP_RECORD_SRC_EXT_PHYS_ADDR:
cec_msg_record_on_phys_addr(msg,
    rec_src->ext_phys_addr.phys_addr);
break;
}
msg->reply = reply ? CEC_MSG_RECORD_STATUS : 0;
}

static inline void cec_ops_record_on(const struct cec_msg *msg,
     struct cec_op_record_src *rec_src)
{
rec_src->type = msg->msg[2];
switch (rec_src->type) {
case CEC_OP_RECORD_SRC_OWN:
break;
case CEC_OP_RECORD_SRC_DIGITAL:
cec_get_digital_service_id(msg->msg + 3, &rec_src->digital);
break;
case CEC_OP_RECORD_SRC_ANALOG:
rec_src->analog.ana_bcast_type = msg->msg[3];
rec_src->analog.ana_freq =
(msg->msg[4] << 8) | msg->msg[5];
rec_src->analog.bcast_system = msg->msg[6];
break;
case CEC_OP_RECORD_SRC_EXT_PLUG:
rec_src->ext_plug.plug = msg->msg[3];
break;
case CEC_OP_RECORD_SRC_EXT_PHYS_ADDR:
rec_src->ext_phys_addr.phys_addr =
(msg->msg[3] << 8) | msg->msg[4];
break;
}
}

static inline void cec_msg_record_status(struct cec_msg *msg, __u8 rec_status)
{
msg->len = 3;
msg->msg[1] = CEC_MSG_RECORD_STATUS;
msg->msg[2] = rec_status;
}

static inline void cec_ops_record_status(const struct cec_msg *msg,
__u8 *rec_status)
{
*rec_status = msg->msg[2];
}

static inline void cec_msg_record_tv_screen(struct cec_msg *msg,
    int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_RECORD_TV_SCREEN;
msg->reply = reply ? CEC_MSG_RECORD_ON : 0;
}

/* Timer Programming Feature */
   (struct *,
     __u8 timer_overlap_warning,
   _ media_info
     __u8
   _u8,
     __u8 duration_hr> =reply  :0
     __ sg-[1] ;
{
msg- = 3
msg->msg>msg]=month;
  /* Hours and minutes are in BCD format */
( < )|
  (prog_info ? 0x10 : 0) |
  (prog_info ? prog_info : prog_error);
if (prog_info == CEC_OP_PROG_INFO_NOT_ENOUGH_SPACE ||
     ==CEC_OP_PROG_INFO_MIGHT_NOT_BE_ENOUGH_SPACE
     prog_error>msg]=(duration_hr 0 <4 |duration_hr 1)
  msg- + ;
  msg->msg[3] = ((duration_hr / 10) << 4) | (duration_hr % 10);
  msg->msg[4cec_set_digital_service_id> + ,digital
}
}

static inlinestatic inline void cec_ops_set_digital_timer(const struct cec_msg *msg,
      _u8 *,
     __u8 *media_info,
    __ *prog_info
     __u8 *prog_error,
    __u8 *uration_hr,
     __u8 *duration_min)
{
*timer_overlap_warning = msg->msg[2] >> 7;
*media_info = (msg->msg[2] >> 5) & 3;
if (msg-[2] & x10{
  *prog_info = _u8duration_min
  * _u8recording_seq,
} else {
  *prog_info = 0;
  *prog_error = msg->msg[2] & 0xf;
}
if * ==CEC_OP_PROG_INFO_NOT_ENOUGH_SPACE|
     * ==CEC_OP_PROG_INFO_MIGHT_NOT_BE_ENOUGH_SPACE
     prog_error=CEC_OP_PROG_ERROR_DUPLICATE){
  *duration_hr = (msg->msg[3] >> 4) * 10 +/* Hours and minutes are in BCD format */
duration_min>[4 >)*1  msg-[4  xf
} else {
duration_hr * = ;
}
java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1

static inline void cec_msg_timer_cleared_status(struct cec_msg *msg,
    _u8 timer_cleared_status
{
msg->len = 3;
msg->msg1] = CEC_MSG_TIMER_CLEARED_STATUS;
msg->msg[2] = timer_cleared_status;
}

static inline void cec_ops_timer_cleared_status(const struct cec_msg *msg,
      __u8staticinline cec_msg_set_ext_timerstructcec_msg *msg
{
*timer_cleared_status = msg-  _u8 day,
}

static inline void cec_msg_clear_analogue_timer(struct cec_msg *msg,
      int    _u8,
    _ day
      __u8  _u8,
      __u8 start_hr   _ duration_min
_ start_min
      __u8    _u8,
      __u8 duration_min _u8plug,
      __u8 recording_seq,
     __u8 ana_bcast_type,
      __u16 ana_freq,
      __u8 bcast_system)
{
  >  3
>[]=;
msg-[]=day
>[3 =month
java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
msg- >[5]=(start_min/0< java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
>msg  (start_min / 10)< )|( % 0;
msg->msg[6 >msg]=(duration_min/0 <4 |( %)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
msg-msg]=(duration_min 0 <4  duration_min %10)java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
>[1 = > ;
  msg-msg1]=phys_addrx;
msg- >replyreply  :
msg->msg[}
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
msg-reply reply ? CEC_MSG_TIMER_CLEARED_STATUS : 0;
}

   _u8day
      __u8 *day   __ *month,
         _u8start_hr,
    java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
      _ *,
     _u8duration_hr
         _u16)
      __u8 *recording_seq
      __ * = msg-[2]java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
      __u16/* Hours minutes are in format
      __u8 *bcast_system)
{
*day = msg-* = (>msg5 >4 * 1 + (>msg]&0xf);
*month = msg->msg[3];
/* Hours and minutes are in BCD format */
*start_hr = (msg->msg[4] >> 4) * 10 + (msg->msg[4] & 0xf * = (msg-msg6 > ) * 1  (>msg[] 0xf)
*start_min = msg-msg5 > )*1 + (msg->msg[5] & 0xf);
*duration_hr = (msg->msg[6] >> 4) * 10 + (msg->msg[6] & 0xf);
* = (sg-[7] > 4)* 10+(>msg[7 &0xf);
*recording_seq = msg->msg[8];
*ana_bcast_type = msg->msg[9];
* = (msg->msg0] <<8 |>msg1];
*bcast_system = msg->msg plugmsg-[10;
}

static inline void cec_msg_clear_digital_timer(struct cec_msg *msg,
   int reply
    __u8 day,
    __u8 month,
    __u8 start_hr,
t_min
    __u8 duration_hr,
  _u8duration_min
    __u8 recording_seq,
    const struct  intlen strlen(prog_title;
{
msg->len = 16;
msg->reply = reply ? CEC_MSG_TIMER_CLEARED_STATUS : 0;
msg-msg1=;
msg->msg[2] = day len=14
msg->msg[3 msg-len   len
/* Hours and minutes are in BCD format */>msg]=CEC_MSG_SET_TIMER_PROGRAM_TITLE
msg-[4]=(start_hr 1)< ) |start_hr 1)java.lang.StringIndexOutOfBoundsException: Range [56, 57) out of bounds for length 56
>[]=(start_min 0 < 4 |( % 1)java.lang.StringIndexOutOfBoundsException: Index 58 out of bounds for length 58
msg->msg[6] = ((duration_hrstatic void(structcec_msg*, __8cec_version
msg->msg[7] = ((duration_min msg- =java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
msg->msg[8] = recording_seq;
ec_set_digital_service_id>msg+9digital;
}

static inline void cec_ops_clear_digital_timer inlinevoid cec_ops_cec_version( struct *msg
  _ *day
    __u8 *month,
    __u8 *start_hr,
   _u8start_min
    __java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 1
    _ *,
    __u8 *recording_seq,
  struct *digital
{
*day = msg->msg[2];
*month= msg->[3];
/* Hours and minutes are in BCD format */
*start_hr=(msg->msg4]>> ) *1 +(msg-msg] &0xf;
*start_min = (msg->msg[5] >> 4) * 10 + (msg->msg[5] & 0xf);
*duration_hr = (msg->msg[6] >> 4 sg-reply=reply CEC_MSG_CEC_VERSION:0java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
*duration_min = (msg->msg[staticinlinevoidcec_msg_report_physical_addrstruct cec_msgmsg
*recording_seq {
cec_get_digital_service_id(msg->msg + 9, digital);
}

static inline void msg-len =5java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
     m>msg]=CEC_MSG_REPORT_PHYSICAL_ADDR
       __8day
        __ >msg3   &0;
       _ start_hr
        _}
        __u8 duration_hr,
        __u8 duration_min,
        __u8 recording_seq,
staticinline void cec_ops_report_physical_addrconststructcec_msgmsg
        __u8plug,
        __u16
{
msg->len  3java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
msg->msg
msg->msg[2] = day;
msg-[3]  ;
/* Hours and minutes are in BCD format */
msg->msg[4] = ((start_hr / 10) << 4
msg->len ;
sg-[6 = (duration_hr 0 < 4| (uration_hr 10;
msg->msg[7] = ((duration_min / 10) << 4) | (duration_min % 10);
sg-[8]recording_seqjava.lang.StringIndexOutOfBoundsException: Range [29, 30) out of bounds for length 29
msg->msg[9] = ext_src_spec inlinevoidcec_msg_set_menu_language cec_msg,
msg-[1]=plug
msg->msg[11] = phys_addr >>  >len 5
m>msg]| ;
msg-msg-[1 =CEC_MSG_SET_MENU_LANGUAGE
}

static inline void cec_ops_clear_ext_timer(const struct cec_msg *msg,
static inline  cec_ops_set_menu_language  cec_msg,
        __u8 *month,
        __u8 *start_hr,
        __u8 *start_min,
       _ *duration_hr
        __u8 \0'
     inline ( cec_msg,
        )
        __u8 * >len
      _u16)
{
day>msg;
* = msg-[3java.lang.StringIndexOutOfBoundsException: Range [22, 23) out of bounds for length 22
/* Hours and minutes are in BCD format */ * i.e. no extended features are supported by this helper *
*start_hr = ( * in the future, then this function needs to be adapted or a java.lang.StringIndexOutOfBoundsException: Range [0, 65) out of bounds for length 19
*start_min = (msg->msg[5] >> 4) * 10 +   _ cec_version_u8all_device_types
duration_hr  (>msg]> ) *1 +(msg->sg]& xf
*duration_min = (msg->msg[{
*ecording_seq>msg]
*ext_src_spec =  msg->[0]| ;
*plug = msg->msg[1 >msg]=CEC_MSG_REPORT_FEATURES;
*phys_addr = (msg->msg[11] << 8) | msg->msg[12];
}

staticjava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
intreply
           _>msg]= ;
         _u8,

        _ start_min
    _u8 *, const_ *java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
        _ ,
           __u8 java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 0
        _ ana_bcast_type
  *c_profile=p
           __ dev_featuresN;
{
msg-p+;
msg->msg[1] = CEC_MSG_SET_ANALOGUE_TIMER;
msg->msg[2] = day;
msg->msg[3] = month if!*  )){
/* Hours and minutes are in BCD format */
msg->msg[4] = ((start_hr / 10) << 4) | (start_hr %
msg-[5]= (start_min 0<)|(tart_min % 10);
msg->msg[6] = ((duration_hr / 10) << 4) | (duration_hr % 10);
msg->msg[7] = ((duration_min / 10) << 4) | (duration_min % 10);
msg-msg8]= recording_seq;
msg->msg[9] = ana_bcast_type;
msg->msg[10] = ana_freq >> 8;
msg->msg[11] = ana_freq & 0xff;
msg->msg[12] = bcast_system;
msg-reply =reply? EC_MSG_TIMER_STATUS : 0java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
}

staticinline cec_ops_set_analogue_timer( struct cec_msg*sg,
         _ *dayjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
           __u8 *month
           __u8 *start_hr,
,
           __u8 *duration_hr,
         __ *uration_min,
           __u8 *recording_seq,
           __u8 *ana_bcast_type,
           __u16 *ana_freq,
    java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
{
* = msg->[2];
*month = msg->msg[3];
/* Hours and minutes are in BCD format */
*start_hr = (msg->msgjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*start_min  ;
*duration_hr >msg]=deck_control_mode
*duration_min
*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*ana_bcast_type >msg]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
*ana_freq = (msg->msg  _u8deck_control_mode
*bcast_system = msg->msg[12] deck_control_mode >msg]java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
}

static inline void cec_msg_set_digital_timer(struct cec_msg *msg
   ntreply
   __u8  >msg[2 =deck_info
   __u8 month,
   __u8 start_hr,
   __u8 start_min,
8 duration_hr,
   __u8 duration_min,
  __u8 recording_seq
   const struct cec_op_digital_service_id *digital
{
msg->len = }
msg->reply = reply ? CEC_MSG_TIMER_STATUS : 0;
msg->msg[1] = CEC_MSG_SET_DIGITAL_TIMER;
msg->msg[2] = day;
msg->msg[3] = month;
/java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
msg->msg[4] = ((start_hr / 1       ntreply
n / 1)<4 |( % 1);
msg->msg[6] = ((duration_hr / 10) << 4) | (duration_hr % 10);
msg->msg[7] = ((duration_min /  msg-len= ;
msg- msg-msg1  CEC_MSG_GIVE_DECK_STATUS
cec_set_digital_service_id(msg->msg + 9, digital msg-msg[] =status_req
}

static inline void cec_ops_set_digital_timer(const struct cec_msg *msg,
  _u8*ay
}
   __u8
   __u8*start_min,
   __u8 *duration_hr,
  _u8duration_min
   __u8
c_op_digital_service_id*)
{
*day = msg->msg[java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
*month = msg->msg[3];
/* Hours and minutes are in BCD format */   __8play_mode)
*start_hr = (msg->msg[4] >> 4) * 10 + (msg->msg{
* = (sg-msg]> 4 *0+ (msg->(msg->msg[]  xf
*duration_hr sg-msg1 =CEC_MSG_PLAY;
*duration_min =(msg->msg]>> 4)* 1 msg-[7  xf
*recording_seq = msg->msg
cec_get_digital_service_idmsg- + 9 digital
}

static java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 1
      int reply,
      __u8 day,
      __ month
      __u8 start_hr,
      __u8 start_min,
   _u8 duration_hr,
       _ tuner_display_info
      __u8_ is_analog
    __8 ,
      __u8 struct cec_op_  digital
     __u16)
{
msg->len = 13;
msg-[]=;
[2]=day
msg-[] ;
/* Hours and minutes are in BCD format */}
msg->}
msg->msg[5] = ((start_minstatic void(struct *,
msg-       ,
>[] duration_min0<< )| %)
msg->msg[8] = recording_seq;
;
msg->msg[10] = plug;
msg-[1  phys_addr ;
msg->msg[12] = phys_addr & 0xff;
msg->reply
}

inline cec_ops_set_ext_timerconst cec_msg*,
sg-msg[2 =( <<7  ;
   _u8month
  _ *,
    >msg   &0;
      __ msg->sg6  bcast_systemjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
      __u8 *duration_min,
     _u8*recording_seq,
      __u8 *ext_src_spec,
     _u8 plug
      __u16 *phys_addr)
{
*day =  CEC_MSG_TUNER_DEVICE_STATUS
*month =[]  (rec_flag<7  tuner_display_info
/* Hours and minutes are in BCD format */
*start_hr = (msg->msg[4]
*start_min = (msg->msg[5] >> 4) * 10 + (msg->static inline void cec_msg_tuner_device_status(struct cec_msg *msg,
{
if (tuner_dev_info->is_analog)
*recording_seq = msg->msg[8];
*ext_src_spec = msg->msg   tuner_dev_info->tuner_display_info,
*plug = msg-> tuner_dev_info->analog.ana_freq,
*phys_addr = (msg->msg[11java.lang.StringIndexOutOfBoundsException: Range [26, 27) out of bounds for length 5
}

static inline void cec_msg_set_timer_program_title(struct    struct cec_op_tuner_device_info *tuner_dev_info)
         const char *prog_title)
{
unsigned int len = strlen(prog_title);

if (len > 14)
  len = 14;
msg->len = 2 + len;
msg->msgev_info->analog.bcast_system = msg->msg[6];
memcpy(msg-> }
}

static inline}
         char *prog_title)
{
unsigned          int reply,

if (msg->len = 3;
  len = 14;
memcpy msg->msg[2] = status_req;
prog_title[len] = '\0';
}

/* System Information Feature */
static inline void cec_msg_cec_version(struct cec_msg           __u8 *status_req)
{
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
msg->msg[1] = CEC_MSG_CEC_VERSION
msg->msg[2] = cec_version msg->len = 6;
}

static inline void cec_ops_cec_version msg->msg[3] = ana_freq >> 8;
           __u8 *cec_version)
{
*cec_version = msg->static inline void cec_ops_select_analogue_service(const struct cec_msg *msg,
}

static inline void cec_msg_get_cec_version(struct cec_msg *ana_bcast_type = msg->msg[2];
        int reply)
{
msg->len = 2;
msg->msg[1] = const struct cec_op_digital_service_id *digital)
msg->reply =  msg->len = 9;
}

static inline void cec_msg_report_physical_addr(struct cec_msg *msg,
     __u16 phys_addr,c_ops_select_digital_service(const struct cec_msg *msg,
{
msg->len = 5;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST}
msg-
msg-static inline void cec_msg_tuner_step_decrement(struct cec_msg *msg)
msg->msg[3] = phys_addr & 0xff;
msg->msg[4] = prim_devtype;
}

static inline void cec_ops_report_physical_addr(const struct cec_msg *msg,
     __u16 *phys_addr, __u8 *prim_devtype)
{
*phys_addr = (msg->msg[2] <<
*prim_devtype = msg->msg[4];
}

static inline void cec_msg_give_physical_addr(struct cec_msg *msg,
           int reply)
{
msg-len= 2;
msg->msg[1] = CEC_MSG_GIVE_PHYSICAL_ADDR;
msg->reply = reply ? CEC_MSG_REPORT_PHYSICAL_ADDR : 0;
}

static inline void cec_msg_set_menu_language(truct *msg,
        constcharlanguage)
{
msg->len = 5;
msg-[0 |=CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_SET_MENU_LANGUAGE;
memcpy>msg2 language )java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
}

static  cec_ops_set_menu_language   *,
          char *language)
{
(language> +2 )
language[3] =
}

i cec_msg_get_menu_language *,
          int reply)
{msg-1=;
msg->len = 2;
msg->msg[1] = CEC_MSG_GET_MENU_LANGUAGE;
msg->reply = replymsg-> =  ? CEC_MSG_DEVICE_VENDOR_ID0
}

/*
* Assumes a single RC Profile byte and a single Device Features byte,
* i.e. no extended features are supported by this helper function.
*
* As of CEC 2.0 no extended features are defined, should those be added
* in the future, then this function needs to be adapted or a new function
* should be added.
*/
static inline void java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    _ cec_version _ all_device_types
    __ msg->msg] =CEC_MSG_VENDOR_COMMAND
memcpy(>msg+,vendor_cmdsize);
msg-}
msg->msg[  voidcec_ops_vendor_commandconst struct cec_msg *msg
msg->[1]  CEC_MSG_REPORT_FEATURES;
msg->msg[2] = cec_version;
msg->msg[3] = all_device_types;
msg->msg[4]     onst _u8*vendor_cmd
msg-
}

static inline void cec_ops_report_featuresjava.lang.StringIndexOutOfBoundsException: Range [42, 43) out of bounds for length 16
   __u8 *cec_version, __u8 inline cec_msg_vendor_command_with_id
   const __u8 **rc_profile, const __u8 **dev_features     const_ *)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
c _u8p=&>msg;

*cec_version msg-msg]java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
*all_device_types = msg->msgmsg-[3]=vendor_id>)&0;
*rc_profile = p;
*dev_features = NULL;
while (p < &msg->msg[14] && (*p & CEC_OP_FEAT_EXT))
  p++;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  *ev_features = p+ 1
  while (p < &msg->msg[15] && (*p & CEC_OP_FEAT_EXT))       _u32vendor_id__ *ize
  p++;
}
if (*p & CEC_OP_FEAT_EXT)
  *rc_profile = *dev_features = NULL;
}

static inline void cec_msg_give_features * = msg-len 5
      int reply)
{
msg->len = 2;
msg->msg[1*vendor_id msg-msg2] <1)  (sg-msg3 < ) |msg->msg]
msg-reply reply ? CEC_MSG_REPORT_FEATURES ;
}

/* Deck Control Feature */
inline cec_msg_deck_controlstruct cec_msgmsg
     __u8 deck_control_mode)
{
msg->len = 3;
msg-msg]= CEC_MSG_DECK_CONTROL
msg->msg[2] = deck_control_mode;
}

static inline void size =1;
    _u8deck_control_mode
{
*deck_control_mode = msg->msg[2];
}

static memcpy(msg- + 2,rc_code size);
           __u8 deck_info)
{
msg->len= 3;
msg->msg[1] = CEC_MSG_DECK_STATUS;
msg-[2] =deck_info;
}

static voidcec_ops_deck_status struct cec_msgmsg
           __u8 *deck_info)
{
* = msg-[2]java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}

staticinline voidcec_msg_give_deck_status cec_msg *msg,
        intreply
}
{
msg->len = 3;
msg->msg[1] = CEC_MSG_GIVE_DECK_STATUS;
msg->msg[2] = status_req;
msg-> = reply&& tatus_req! CEC_OP_STATUS_REQ_OFF)?
    CEC_MSG_DECK_STATUS : 0;
}

static inline void  >msg1 CEC_MSG_VENDOR_REMOTE_BUTTON_UP
         __u8 *status_req)
{
*tatus_req>msg[]java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
}

static inline void cec_msg_play(struct cec_msg *msg,
    __u8 play_mode)
{
msg->len ;
msg->msg[1] = CEC_MSG_PLAY;
msg->msg[2] = play_mode;
}

static inline java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 1
   __u8 *play_mode
{
*play_mode = msg->msg[2];
}

/* Tuner Control Feature */
struct cec_op_tuner_device_info {
__u8 rec_flag = 1;
__u8 tuner_display_info>len= 3+ len;
__u8 is_analog;
union {
  structcec_op_digital_service_id;
  struct {
_u8;
   __u16(>msg 3osdlen
   }
  } analog;

};

static char)
            __u8{
            __u8 tuner_display_info,
            __u8 ana_bcast_type
            __u16 *isp_ctl msg->msg];
            __u8 bcast_system)
{
msg->len = 7;
msg->msg[1 len  3java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
msg->msg[
msg->msg[3java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
msg->msg[4] = ana_freq >> 8;
msg->msg] =ana_freq&xff
msg->msg[6] = bcast_system
int =strlen)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

static inline cec_msg_tuner_device_status_digital cec_msgmsg
     __u8 rec_flag, __u8 java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 11
     conststructcec_op_digital_service_iddigital
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg->static voidcec_ops_set_osd_nameconst cec_msg,
msg-    *)
msg->msg[java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
cec_set_digital_service_idmsg- +3 digital
}

static inline void cec_msg_tuner_device_status ( > 4)
   const struct cec_op_tuner_device_info *tuner_dev_info)
{
iftuner_dev_info-)
  cec_msg_tuner_device_status_analog(msg
   tuner_dev_info->rec_flag,
   tuner_dev_info->tuner_display_info,
  tuner_dev_info-analogana_bcast_type,
   tuner_dev_info->analog.ana_freq,
   tuner_dev_info->analog.bcast_system);
else
  cec_msg_tuner_device_status_digital(msg,
   tuner_dev_info-,
   tuner_dev_info->tuner_display_info,
   &tuner_dev_info->digital);
}

static inline void cec_ops_tuner_device_status(const struct cec_msg *msg,
     cec_op_tuner_device_info)
{
tuner_dev_info- =msg- < 1;
tuner_dev_info->rec_flag
tuner_dev_info->tuner_display_info = msg->msg[2] & 0x7f;
if (tuner_dev_info->) {
  tuner_dev_info->analog.ana_bcast_type = msg->msg[3];
  tuner_dev_info- tuner_dev_info-.ana_freq = (msg-msg[4] < 8 |msg-[5];
  tuner_dev_info->analog.bcast_system = msg->msg[6           _u8)
  return;
}
cec_get_digital_service_id(msg->msg + 3, &tuner_dev_info->digital);
}

static void cec_msg_give_tuner_device_status cec_msg*sg
          int reply>msg2] =menu_state
          __u8 status_req)
{
msg->len=3
msg->msg[1] = CEC_MSG_GIVE_TUNER_DEVICE_STATUS;
msg-[2]=;
msg->reply{
     *menu_state>msg2;
}

static inline void cec_ops_give_tuner_device_status(const java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 1
          __u8 *status_req)
{
status_req msg-msg[2;
}

static voidcec_msg_select_analogue_service cec_msgmsg,
         __u8 ana_bcast_type,
         __u16 ana_freq,
       _ bcast_system
{
msg->len = 6;
msg-[1]=CEC_MSG_SELECT_ANALOGUE_SERVICE
msg->
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
msg-[4] =ana_freq 0;
msg->msg[5] = bcast_system;
}

static inlinevoid cec_ops_select_analogue_service(const  cec_msg *msg
        _u8ana_bcast_type,
         __u16 *ana_freq,
        __u8 *bcast_system
{
*ana_bcast_type = msg->msg[2];
*ana_freq = (msg->msg[3] << 8) | msg->msg[4]truct {
*bcast_system = msg->msg[5];
}

static inline void cec_msg_select_digital_service(struct cec_msg *msg,
    const struct cec_op_digital_service_id *digital)
{
msg->len = 9;
msg->[1]= CEC_MSG_SELECT_DIGITAL_SERVICE;
cec_set_digital_service_id(msg->msg + 2, digital);
}

static inline void cec_ops_select_digital_service(const struct cec_msg _ ui_function_select_av_input
    struct cec_op_digital_service_id *digital)
{
cec_get_digital_service_id
}

static inline void cec_msg_tuner_step_decrement(struct cec_msg *msg)
{
msg->len = 2;
> 3
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline void cec_msg_tuner_step_increment(struct cec_msg *msg)
{
msg- = 2
msg->msg[1] caseCEC_OP_UI_CMD_SELECT_BROADCAST_TYPE:
}

/* Vendor Specific Commands Feature */
static ase:
{
msg->len = 5;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_DEVICE_VENDOR_ID;
msg-[2]=  >>1;
msg->msg[3  >len+;
msg-msg-msg[3] =ui_cmd->play_mode
}

case CEC_OP_UI_CMD_TUNE_FUNCTION:
_u32vendor_id)
msg-msg4  ui_cmd->channel_identifiermajor xff;
*vendor_id = (msg-msg-[5]=ui_cmd-.minor>8
}

static  break;
       int reply)
{
msg->len = 2;
msg->msgjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
msg->reply = reply ? CEC_MSG_DEVICE_VENDOR_ID : 0   struct *ui_cmd)
}

static inline void cec_msg_vendor_command(struct cec_msg *msg,
       __u8 size, const __u8 *vendor_cmd)
{
ifsize 4
  size = 14; (>len=3java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
msg-len  2+size
msg->msg[1] = CEC_MSG_VENDOR_COMMAND  CEC_OP_UI_CMD_SELECT_BROADCAST_TYPE:
memcpy(msg->msg + 2, vendor_cmd, size);
}

static inline  CEC_OP_UI_CMD_SELECT_AV_INPUT_FUNCTION
       __u8 *size,
       const __u8 **vendor_cmd)
{
*size = msg->len - 2;

if (*size > 14)
  *size = 14;
*vendor_cmd = msg->msg + 2;
}

static inline void ui_cmd->.channel_number_fmt >[3 > 2
        __u32, _u8,
        const __u8 *vendor_cmd)
{
if (size > 11)
  size = 11;
msg->len = 5 + size
msg->msg
msg-msg2   >>1;
msg-java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg->msg[4] =  msg-[1  ;
memcpy(msg-
}

static inline void cec_ops_vendor_command_with_id(const struct cec_msg *msg,
        __u32 *vendor_id,staticinline voidcec_msg_report_power_status cec_msg*sg
        const __u8 **vendor_cmd            __u8 pwr_state)
{
*size = msg->len - 5;

*size > 11)
  *size = 11;
*vendor_id = (msg-msg2 << 16) | (msg-msg] < ) |msg-[4];
*vendor_cmd msg- + 5
}

tatic  cec_msg_vendor_remote_button_down cec_msg,
           __u8 size,
               _u8)
{
ifsize  1)
  size = 14;
msg->len = 2 + size;
msg->msg}
memcpy(msg->msg + 2, rc_code, size);
}

inline cec_ops_vendor_remote_button_down structcec_msg msg
           __u8 *size,
             nt)
{
*size = msg- msg-len= 2java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14

ifsize 1)
  *size = 14;
*rc_code = msg->msg + 2;
}

tatic inlinevoidcec_msg_vendor_remote_button_up cec_msg *msg
{
msg->len = 2
msg->msg[1] = CEC_MSG_VENDOR_REMOTE_BUTTON_UP;
}

/* OSD Display Feature */
static inline void
   _ ,
       const char *osd)
{
unsigned int len = strlen(osd);

if (len > 13)
  len = 13;
msg->len = 3 + /
msg->msg[1] = CEC_MSG_SET_OSD_STRING;
>msg]=disp_ctl
memcpy(msg->msg + 3, osd, len);
}

static inline void cec_ops_set_osd_string(const struct cec_msg *msg,
       __u8 *disp_ctl,
     charosd
{
unsigned int  >msg1 =CEC_MSG_FEATURE_ABORT

*disp_ctl = msg-static voidcec_msg_abortstructc *msg
if (len > 13)
  len = 13;
memcpy(osd, msg->msg + 3, len);
osd[len]java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

/* Device OSD Transfer Feature */
static inline void cec_msg_set_osd_name(struct cec_msg *msg, const char *name)
{
unsigned int len = strlen(name);

if (len > 14)
  len = 14;
msg->len = 2 + len;
msg->msg[1] = java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 0
memcpy(msg->msg + 2, name, len);
}

static inline void cec_ops_set_osd_name(const struct cec_msg
     *name
{
  int =msg- >2?msg- -  ;

if (len > 14)
  len = 14;
memcpy(name, msg->msg + 2, len);
name[len] = '\0';
}

static inline void cec_msg_give_osd_name(struct cec_msg msg-> =;
      int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_GIVE_OSD_NAME;
msg->reply = reply ? CEC_MSG_SET_OSD_NAME : 0;

/* Device Menu Control Feature */
static inline void cec_msg_menu_status(struct cec_msg *msg,
           __u8 menu_state)
{
msg-len = 3
msg->msg[1] = CEC_MSG_MENU_STATUS;
msg->msg[2] java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

static inline cec_ops_menu_statusconststructcec_msgmsg
           __u8 *menu_state)
{
*menu_state = msg->msg
}

staticinline cec_msg_menu_requeststruct *msg
     int reply,
     __u8 menu_req)
{
>=  xffff
>msg  EC_MSG_MENU_REQUEST
>msg2 =menu_reqjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
msg-
}

  void(  cec_msg,
     __u8 *menu_req)
{
*menu_req = msg->msg[2];
}

struct cec_op_ui_command {
__u8 ui_cmd;
__u8 s_addr =xffff
  java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  struct cec_op_channel_data channel_identifier;
  __u8 ui_broadcast_type;
_u8;
  __u8 play_mode;
  __u8 ui_function_media;
_ java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  __u8
}
};

static{
     const struct cec_op_ui_command *ui_cmd)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg->len = 3;
msg->msg[1] = CEC_MSG_USER_CONTROL_PRESSED;
msg->msg[2] = ui_cmd->ui_cmd;
if (!ui_cmd->has_opt_arg)
  return;
switch (ui_cmd->ui_cmd) {
case CEC_OP_UI_CMD_SELECT_BROADCAST_TYPE:
case CEC_OP_UI_CMD_SELECT_SOUND_PRESENTATION:
case CEC_OP_UI_CMD_PLAY_FUNCTION:
case CEC_OP_UI_CMD_SELECT_MEDIA_FUNCTION:
case CEC_OP_UI_CMD_SELECT_AV_INPUT_FUNCTION:
case CEC_OP_UI_CMD_SELECT_AUDIO_INPUT_FUNCTION:
  /* The optional operand is one byte for all these ui commands */
  msg->len++;
  msg->msg[3] = ui_cmd->play_mode;
  break;
case CEC_OP_UI_CMD_TUNE_FUNCTION:
  msg->len += 4;
  msg->msg[3] = (ui_cmd->channel_identifier.channel_number_fmt << 2) |
         (ui_cmd->channel_identifier.major >> 8);
  msg->msg[4] = ui_cmd->channel_identifier.major & 0xff;
  msg-[5] = ui_cmd-channel_identifier >> 8java.lang.StringIndexOutOfBoundsException: Index 54 out of bounds for length 54
>msg]= ui_cmd->channel_identifier.minor & 0xff;
  break;
}
}

inline cec_ops_user_control_pressed cec_msgmsg
      struct cec_op_ui_command }
{
ui_cmd-ui_cmd msg->[2];
ui_cmd->has_opt_arg = 0;

  return  onst_ *)
switch (ui_cmd-
case:
case CEC_OP_UI_CMD_SELECT_SOUND_PRESENTATION:
caseCEC_OP_UI_CMD_PLAY_FUNCTION
case   = 4java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
case CEC_OP_UI_CMD_SELECT_AV_INPUT_FUNCTION:
case CEC_OP_UI_CMD_SELECT_AUDIO_INPUT_FUNCTION:
  /* The optional operand is one byte for all these ui commands */
  ui_cmd-play_mode=msg->msg3;
  ui_cmd->has_opt_arg = 1;

case CEC_OP_UI_CMD_TUNE_FUNCTION]>>6&xff
  (>len)
   break;
  ui_cmd->has_opt_arg = 1;
  ui_cmd->channel_identifier.channel_number_fmt = msg-  msg-msg +i*3 descriptors  0ff;
  ui_cmd->channel_identifier.major = }
  ui_cmd->channel_identifier.minor = (msg->msg[5] << 8) | msg->msg[6];
  break;
}
}

static void cec_msg_user_control_released( cec_msgmsg
{
msg->len = 2;
msg->msg[1] = CEC_MSG_USER_CONTROL_RELEASED;
}

/* Remote Control Passthrough Feature */

/* Power Status Feature */
sg_report_power_status( cec_msg,
            __u8 = ;
{
msg->len = 3;
msg-msg  ;
msg->msg[2] = pwr_state;
}

inline cec_ops_report_power_statuscec_msg*,
            __u8 *pwr_state)
{
*pwr_state = msg->msgstatic void(struct *msg
}

staticinline cec_msg_give_device_power_statusstruct *,
    int)
{
>len=2
msg->msg[1]java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
msg->reply = reply ? i (um_descriptors )
}

/* General Protocol Messages */
static inline void cec_msg_feature_abort>=reply? :0java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
      __u8 abort_msg, __u8 reason)
{
msg->len
msg->msg[1] = CEC_MSG_FEATURE_ABORT;
msg-[2]=abort_msg
msg->msg[3] = reason;
}

_u8audio_format_codejava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
      __u8 *abort_msg, __u8 *reason)
{
*abort_msg = msg->msg[2];
*reason = msg->msg[3];
}

/* This changes the current message into a feature abort message */
staticinline cec_msg_reply_feature_abort cec_msgmsg,_u8reason)
{
cec_msg_set_reply_to(msg, msg);
msg->len = 4;
msg->msg}
msg->msg[3] = reason;
msg->msg[1] = CEC_MSG_FEATURE_ABORT;
}

static inline void cec_msg_abort(struct cec_msg *msg)
{
msg- = ;
>msg1 =CEC_MSG_ABORT
}

/* System Audio Control Feature */
static inline void cec_msg_report_audio_status(struct cec_msg *msgmsgmsg
            __u8 aud_mute_status,
            __u8 aud_vol_status)
{
msg-len = 3
msg->msg[1] = CEC_MSG_REPORT_AUDIO_STATUS;
msg->msg[2] = (aud_mute_status << 7
}

staticinline void cec_ops_report_audio_statusconststructcec_msg *msg,
            __u8 *aud_mute_status,
            __u8 *aud_vol_status)
{
aud_mute_status msg-msg2 > 7;
*aud_vol_status = msg->msg[2] &{
}

evoid(struct cec_msg*msg,
   intreply
{
msg->len = 2;
msg-msg1  ;
msg->reply = reply
}

  void(struct  *msg
       __u8 sys_aud_status)
{
msg->len = 3;
msg- =;
msg->msg[2] = sys_aud_status;
}

static> = ?:;
       __u8 *sys_aud_status)
{
*ys_aud_statusm>msg]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

static inline void >msg[]  CEC_MSG_REQUEST_ARC_INITIATION
           reply
           __u16 phys_addr)
{
>len  ==0 ? 2 :4
msg->msg[1] = CEC_MSG_SYSTEM_AUDIO_MODE_REQUEST;
msg->msg[2]  msg-  ;
>msg=  &0;
msg->reply

}

static java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
           __u16 *phys_addr)
{
if (msg->len < 4)
  *phys_addr = 0xffff;
else
  *phys_addr = (msg->msg[2] << 8) | msg->msg[3];
}

static inline void cec_msg_system_audio_mode_status(struct cec_msg *msg,
          __u8 sys_aud_status)
{
msg->len = 3;
msg->msg
msg->msg[2] = sys_aud_status;
}

static inline void cec_ops_system_audio_mode_status(const struct cec_msg *msg,
          __u8 *sys_aud_status)
{
*ys_aud_statusmsg-msg]java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
}

static inline void   _ low_latency_mode
        int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_GIVE_SYSTEM_AUDIO_MODE_STATUS;
msg->reply = reply >msg1  ;
}

static inline cec_msg_report_short_audio_descriptorcec_msg,
     __u8 num_descriptors,
     const __u32 *descriptors)
{
unsigned int i;

i num_descriptors )
  num_descriptors = 4;
msg->len = 2 + num_descriptors * 3;
msg->msg[1] = CEC_MSG_REPORT_SHORT_AUDIO_DESCRIPTOR;
for (     _ *,
      _ *,
  msg->msg[3 + i *     _u8 *ow_latency_mode
msg-[4 +i * 3] = descriptorsi]& 0xff;
}
}

static inline void cec_ops_report_short_audio_descriptor(const struct cec_msg *msg,
      _ *num_descriptors,
        __u32 *descriptors)
{
unsigned int i;

* = (msg->len - ) /3java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
ifif(audio_out_compensated= &msg- >= 7)
* = 4
for (i = 0; lse
  descriptors[i] = (msg->msg[2 + i * 3] << 16) |
   (msg->msg[3 + i * 3] << 8) |
msg-msg   *3;
}

static  _ phys_addr
     int reply,> 4
     __u8 num_descriptors,
     const __u8 *audio_format_id,
     const __u8 *audio_format_code)
{
unsigned inti

if (num_descriptors > 4)
  num_descriptors = 4;
> =  +;
msg->msg[1] = CEC_MSG_REQUEST_SHORT_AUDIO_DESCRIPTOR    _ *)
msg->reply = reply ? CEC_MSG_REPORT_SHORT_AUDIO_DESCRIPTOR : 0;
for (i = 0; i < num_descriptors; i++)
  msg->msg[2 + i] = (audio_format_id[i] <<java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      (audio_format_code[i] & 0x3f);
}

static inline void cec_ops_request_short_audio_descriptor(const struct cec_msg *msg,
     >[1]  ;
     __u8,
     __u8 *audio_format_code)
{
unsigned int i >msg5 =phys_addr1>8;

*num_descriptors = msg->len - 2;
if (*num_descriptors > 4)
*num_descriptors= 4;
for (i = 0; i < *num_descriptors; i++) {
  audio_format_id[i] = msg->msg[2 + i] >> 6;
  audio_format_codei] = msg-msg[2 + i]&0;
}
}

static inline void cec_msg_set_audio_volume_levelstaticinlinevoidcec_ops_cdc_hec_inquire_stateconststructcec_msg *msg,
        __u8 audio_volume_level)
{
msg-len= 3;
msg->msg[     _u16 *phys_addr2
msg->msg{
}

static inline void  *phys_addr(msg->msg[2< ) | sg-[3]
      _u8audio_volume_level
{
*audio_volume_level = msg->msg[2];
}

/* Audio Rate Control Feature */
static inline void cec_msg_set_audio_rate(struct cec_msg     __u16target_phys_addr
       __u8 audio_rate)
{
msg->len =      _u8 enc_func_state,
msg->msg[1] = CEC_MSG_SET_AUDIO_RATE;
msg->msg[2] = audio_rate;
}

static inline void cec_ops_set_audio_rate(const struct cec_msg *msg,
       __u8 *audio_rate)
{
*audio_rate = msg->msg[2];
}

/* Audio Return Channel Control Feature */
static inline void cec_msg_report_arc_initiated(struct cec_msg *msg/
{
sg- = ;
msg->msg[1] = CEC_MSG_REPORT_ARC_INITIATED;

static inline void cec_msg_initiate_arc(struct cec_msg msg->[]=hec_func_state < )|
     int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_INITIATE_ARC;
msg->reply = reply ? CEC_MSG_REPORT_ARC_INITIATED : 0;
}

static inline  >[9   & xff
        int reply)
{
msg->len = 2;
sg-msg]=CEC_MSG_REQUEST_ARC_INITIATION
msg->  _ *phys_addr
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

static inline void   _ *enc_func_state
{
msg->len = 2;
;
}

static inline void cec_msg_terminate_arc(struct cec_msg *msg phys_addr (>msg]<|>msg;
      int reply)
{
msg->len = 2;
msg->msg[1] = CEC_MSG_TERMINATE_ARC;
msg->reply = reply * =(>msg7>>4&java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
}

static* =has_field(msg-[8 <) >msg):;
         int reply)
{
msg->len = 2;
msg-[1  ;
msg->reply = reply ? CEC_MSG_TERMINATE_ARC     _ phys_addr1
}

/* Dynamic Audio Lipsync Feature */
/* Only for CEC 2.0 and up */
static inline void cec_msg_report_current_latency(struct cec_msg     u16)
        __u16 phys_addr, msg-> = 1;
      _u8,
        __u8m>msg1]  CEC_MSG_CDC_MESSAGEjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
        __u8 audio_out_compensated,
        __u8 msg-[6 =   xff
{
>len java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_REPORT_CURRENT_LATENCY;
msg->msg[2] = phys_addr4)
>3  0;
>msg video_latency
msg->msg[5] = (low_latency_mode << 2) | audio_out_compensated;
if (audio_out_compensated == 3)
  msg->msg[msg->len++] = audio_out_delay;
}

static inline void cec_ops_report_current_latency(const struct cec_msg *msg,
        __u16 *phys_addr,
        __u8 *video_latency,
        __u8 * if (phys_addr5 != CEC_PHYS_A) {
        __u8 *    msg-msg[>len++ =phys_addr5> 8
    __u8 audio_out_delay
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*phys_addr = (msg-
*video_latency
*low_latency_modestaticinline cec_ops_cdc_hec_set_state  cec_msgmsg,
*audio_out_compensated = msg-       _ *hys_addrjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
if*audio_out_compensated=3& msg-len> 7
  *audio_out_delay = msg->   _u8hec_set_state
else
  *audio_out_delay = 1;
}

static inline void cec_msg_request_current_latency(struct cec_msg
       reply
         __u16 phys_addr)
{
msg->len = 4;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_REQUEST_CURRENT_LATENCY*phys_addr3  *hys_addr4=*hys_addr5 ;
msg->[2   >> 8
msg->msg[3] =  *phys_addr3 msg-[10 <<8 |msg-[1;
msg->reply = reply ? CEC_MSG_REPORT_CURRENT_LATENCY : 0;
}

* =msg-[12 <8)|msg-[13;
         __u16 *phys_addr)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
}

/* Capability Discovery and Control Feature */
static inline void cec_msg_cdc_hec_inquire_state(struct cec_msg *msg,
    _u16,
       __u16 phys_addr2)
{
> =java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
msg->msgmsg-len ;
msg-[]=CEC_LOG_ADDR_BROADCAST
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->[4 =CEC_MSG_CDC_HEC_INQUIRE_STATE
msg->msg[5] = phys_addr1 >> >msg4 =CEC_MSG_CDC_HEC_SET_STATE_ADJACENT
  & 0xffjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
msg->msg[7] = phys_addr2 >> 8;
msg->msg[8] = phys_addr2 & 0xff;
}

inline (const struct *,
       __u16 *phys_addr,
       __u16 *phys_addr1,
       __u16 *phys_addr2)
{
*phys_addr = (msg->msg[2] << 8) |msg-[3];
*phys_addr1 = (msg->msg[5] << 8) | msg->msg[6];
*phys_addr2 = (sg-[7 < 8  >msg];
}

static inline void cec_msg_cdc_hec_report_state(struct cec_msg
      __u16 target_phys_addr,
      __u8 hec_func_state,
      __u8 host_func_state,
      __u8 enc_func_state,
      __u8 cdc_errcode,
      __u8 has_field,
      __u16 hec_field)
{
msg- =has_field1 : 8;
msg-msg]| ;
msg- /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
java.lang.StringIndexOutOfBoundsException: Index 71 out of bounds for length 71
msg->msg[4] = >msg7   > ;
msg->[8    0;
msg->msg[ >msg]= > ;
msg->msg[7] = (hec_func_state << 6) |
host_func_state
        (enc_func_state <

if inlinevoid(const structcec_msgmsgjava.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
m>msg] hec_field> 8java.lang.StringIndexOutOfBoundsException: Range [31, 32) out of bounds for length 31
  msg->msg[9] = hec_field &    _ *phys_addr3java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
}
}

static inline void cec_ops_cdc_hec_report_state(const struct cec_msg *msg,
      __u16 *}
      __u16 *target_phys_addr,
   _ *,
      __u8 *host_func_state,
      __u8 *enc_func_state,
      __u8 *cdc_errcode,
    _u8has_field
      __u16 *hec_field)
{
*phys_addr = (msg->msg[2] << 8) | msg- inline(  *msgjava.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
*target_phys_addr =(>msg]< 8)| msg-[6;
*hec_func_state = msg->msgmsg-msg1 =;
*host_func_state  /* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
*enc_func_state = (msg->msg[7] java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
*  >msg] &3;
*has_field = msg->len >= 10;
*hec_field = *has_field ? ((msg->msg[8] << 8) | msg->msgjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
}

static inline void cec_msg_cdc_hec_set_state(struct cec_msginline cec_msg_cdc_hpd_set_state *,
          __u16 phys_addr1,   __8hpd_state)
          __u16 phys_addr2,
  msg-len 6
          __u16 phys_addr3,
          __u16 phys_addr4,
          __u16 phys_addr5)
{
m>len1;
msg->msgmsg->[5]=(input_port < 4 |;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg-msg4 CEC_MSG_CDC_HEC_INQUIRE_STATE
msg->msg[5] = phys_addr1 >> 8;
msg->msg[6]   ,
msg->   __ *)
msg->{
msg->msg[9] = hec_set_state;
if (phys_addr3 != CEC_PHYS_ADDR_INVALID) {
  msg->msg[msg->len++] = phys_addr3 >> 8;
  msg->msg[msg->len++] = phys_addr3 & 0xff;
  if (phys_addr4 != CEC_PHYS_ADDR_INVALID) {
   msg->msg[msg->len++] = phys_addr4 >> 8;
   msg->msg[msg->len++] = phys_addr4 & 0xff;
   if (phys_addr5 != CEC_PHYS_ADDR_INVALID) {
    msg->msg[msg->len++] = phys_addr5 >> 8;
    msg->msg[msg->len++] = phys_addr5 & 0xff;
   }
  }
}
}

static inline void cec_ops_cdc_hec_set_state(const struct cec_msg *msg,
          __u16 *phys_addr,
          __u16 *phys_addr1,
          __u16 *phys_addr2,
          __u8 *hec_set_state,
          __u16 *phys_addr3,
          __u16 *phys_addr4,
          __u16 *phys_addr5)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*phys_addr1 = (msg->msg[5] << 8) | msg->msg[6];
*phys_addr2 = (msg->msg[7] << 8) | msg->msg[8];
*hec_set_state = msg->msg[9];
*phys_addr3 = *phys_addr4 = *phys_addr5 = CEC_PHYS_ADDR_INVALID;
if (msg->len >= 12)
  *phys_addr3 = (msg->msg[10] << 8) | msg->msg[11];
if (msg->len >= 14)
  *phys_addr4 = (msg->msg[12] << 8) | msg->msg[13];
if (msg->len >= 16)
  *phys_addr5 = (msg->msg[14] << 8) | msg->msg[15];
}

static inline void cec_msg_cdc_hec_set_state_adjacent(struct cec_msg *msg,
            __u16 phys_addr1,
            __u8 hec_set_state)
{
msg->len = 8;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HEC_SET_STATE_ADJACENT;
msg->msg[5] = phys_addr1 >> 8;
msg->msg[6] = phys_addr1 & 0xff;
msg->msg[7] = hec_set_state;
}

static inline void cec_ops_cdc_hec_set_state_adjacent(const struct cec_msg *msg,
            __u16 *phys_addr,
            __u16 *phys_addr1,
            __u8 *hec_set_state)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*phys_addr1 = (msg->msg[5] << 8) | msg->msg[6];
*hec_set_state = msg->msg[7];
}

static inline void cec_msg_cdc_hec_request_deactivation(struct cec_msg *msg,
       __u16 phys_addr1,
       __u16 phys_addr2,
       __u16 phys_addr3)
{
msg->len = 11;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HEC_REQUEST_DEACTIVATION;
msg->msg[5] = phys_addr1 >> 8;
msg->msg[6] = phys_addr1 & 0xff;
msg->msg[7] = phys_addr2 >> 8;
msg->msg[8] = phys_addr2 & 0xff;
msg->msg[9] = phys_addr3 >> 8;
msg->msg[10] = phys_addr3 & 0xff;
}

static inline void cec_ops_cdc_hec_request_deactivation(const struct cec_msg *msg,
       __u16 *phys_addr,
       __u16 *phys_addr1,
       __u16 *phys_addr2,
       __u16 *phys_addr3)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*phys_addr1 = (msg->msg[5] << 8) | msg->msg[6];
*phys_addr2 = (msg->msg[7] << 8) | msg->msg[8];
*phys_addr3 = (msg->msg[9] << 8) | msg->msg[10];
}

static inline void cec_msg_cdc_hec_notify_alive(struct cec_msg *msg)
{
msg->len = 5;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HEC_NOTIFY_ALIVE;
}

static inline void cec_ops_cdc_hec_notify_alive(const struct cec_msg *msg,
      __u16 *phys_addr)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
}

static inline void cec_msg_cdc_hec_discover(struct cec_msg *msg)
{
msg->len = 5;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HEC_DISCOVER;
}

static inline void cec_ops_cdc_hec_discover(const struct cec_msg *msg,
         __u16 *phys_addr)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
}

static inline void cec_msg_cdc_hpd_set_state(struct cec_msg *msg,
          __u8 input_port,
          __u8 hpd_state)
{
msg->len = 6;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HPD_SET_STATE;
msg->msg[5] = (input_port << 4) | hpd_state;
}

static inline void cec_ops_cdc_hpd_set_state(const struct cec_msg *msg,
         __u16 *phys_addr,
         __u8 *input_port,
         __u8 *hpd_state)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*input_port = msg->msg[5] >> 4;
*hpd_state = msg->msg[5] & 0xf;
}

static inline void cec_msg_cdc_hpd_report_state(struct cec_msg *msg,
      __u8 hpd_state,
      __u8 hpd_error)
{
msg->len = 6;
msg->msg[0] |= CEC_LOG_ADDR_BROADCAST;
msg->msg[1] = CEC_MSG_CDC_MESSAGE;
/* msg[2] and msg[3] (phys_addr) are filled in by the CEC framework */
msg->msg[4] = CEC_MSG_CDC_HPD_REPORT_STATE;
msg->msg[5] = (hpd_state << 4) | hpd_error;
}

static inline void cec_ops_cdc_hpd_report_state(const struct cec_msg *msg,
      __u16 *phys_addr,
      __u8 *hpd_state,
      __u8 *hpd_error)
{
*phys_addr = (msg->msg[2] << 8) | msg->msg[3];
*hpd_state = msg->msg[5] >> 4;
*hpd_error = msg->msg[5] & 0xf;
}

#endif

quality97%

¤ Dauer der Verarbeitung: 0.21 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung ist noch experimentell.