Abstract:
The present disclosure relates to a pre-5 th -Generation (5G) or 5G communication system to be provided for supporting higher data rates Beyond 4 th -Generation (4G) communication system. Disclosed is a method of receiving a video segment from at least one streaming server by a client device using hypertext transfer protocol (HTTP) adaptive streaming in a wireless network. The method includes: acquiring media presentation description (MPD) information by receiving an MPD file from the streaming server and parsing the received MPD file; determining a first parameter to minimize a cost function considering both energy consumption required for receiving a video segment and video quality of the segment based on the MPD information; requesting at least one video segment to the at least one streaming server during a first segment request round based on the first parameter; and receiving the at least one video segment from the at least one streaming server.

Description:
RELATED APPLICATION(S) 
       [0001]    This application claims priority under 35 U.S.C. §119(a) to Korean Application Serial No. 10-2014-0139759, which was filed in the Korean Intellectual Property Office on Oct. 16, 2014, the entire content of which is hereby incorporated by reference. 
       BACKGROUND 
       [0002]    The present disclosure relates to an HTTP adaptive streaming method and apparatus considering energy consumption of a mobile terminal in a heterogeneous wireless network. 
         [0003]    To meet the demand for wireless data traffic having increased since deployment of 4G (4 th -Generation) communication systems, efforts have been made to develop an improved 5G (5 th -Generation) or pre-5G communication system. Therefore, the 5G or pre-5G communication system is also called a ‘Beyond 4G Network’ or a ‘Post LTE System’. 
         [0004]    The 5G communication system is considered to be implemented in higher frequency (mmWave) bands, e.g., 60 GHz bands, so as to accomplish higher data rates. To decrease propagation loss of the radio waves and increase the transmission distance, the beamforming, massive multiple-input multiple-output (MIMO), Full Dimensional MIMO (FD-MIMO), array antenna, an analog beam forming, large scale antenna techniques are discussed in 5G communication systems. 
         [0005]    In addition, in 5G communication systems, development for system network improvement is under way based on advanced small cells, cloud Radio Access Networks (RANs), ultra-dense networks, device-to-device (D2D) communication, wireless backhaul, moving network, cooperative communication, Coordinated Multi-Points (CoMP), reception-end interference cancellation and the like. 
         [0006]    In the 5G system, recent developments include Hybrid FSK and QAM Modulation (FQAM) and sliding window superposition coding (SWSC) as an advanced coding modulation (ACM), and filter bank multi carrier (FBMC), non-orthogonal multiple access (NOMA), and sparse code multiple access (SCMA) as an advanced access technology. 
         [0007]    An adaptive streaming technology corresponds to a technology, which adaptively selects a proper video quality in consideration of a network environment and an environment of a client terminal; that is, adaptive streaming technologies configured to meet quality desired by a user in time-varying wireless network environment. The adaptive streaming technology is applied based on various network protocols, such as a Real-time Transport Protocol (RTP) or a Real-Time Streaming Protocol (RTSP), and a Hypertext Transfer Protocol (HTTP) adaptive streaming technology using the HTTP is spotlighted at present. 
         [0008]    The HTTP adaptive streaming technology may have advantages of improvement of a network compatibility problem of the streaming service. The advantages may arise through the use of the conventional HTTP technology and reuse of the conventional HTTP server for the streaming service. Further, in the HTTP adaptive streaming technology, since a client has a core part of the streaming control, a client-oriented streaming service for may be provided for the client receiving the service. 
         [0009]      FIG. 1  illustrates an example of structures of a server and a client that provide Dynamic Adaptive Streaming over HTTP (DASH) contents. A video provided by a server  100  of the DASH is encoded in various levels of quality. For example, one video may be encoded and stored as a video  120  encoded at a low bitrate, a video  130  encoded at a high bitrate, and a video encoded at an intermediate bitrate. 
         [0010]    One encoded video  120  may include segments  122 ,  124 , and  126  of a predetermined play time unit. The server  100  of the DASH provides information, such as quality of video, play time of a video and a data amount to the client  110 . The information is recorded in a Media Presentation Description (MPD) file  140 . 
         [0011]    The client  110  makes a request for the MPD  140  to the server  100  for DASH service. When the client  110  receives the MPD  140  from the server  100 , the client  110  may know information such as quality of a video stored in the server  100 , a play time of the video, and the like. Thereafter, the client  110  may make a request for a segment according to a network state and an environment of a client terminal based on the received MPD. The client  110  makes a request for the segment through an HTTP  150 , receives the segment in response to the request, and plays a video. 
         [0012]    The client  110  may include a controller  112  that performs an operation of requesting/receiving the MPD and requesting/receiving the segment and a media play unit  114  that receives the received segment and plays media. 
         [0013]    DASH technology, however, operates on a single network. Accordingly, when a state of a wireless channel for communication is not good or traffic congestion occurs, a smooth service is not possible even though the adaptive streaming technology is applied. 
         [0014]    Thus, new technologies to remove limitations of a single network through the use of a plurality of networks by the client in a heterogeneous wireless network environment have been proposed. When the client simultaneously uses a plurality of networks, the limitation of the single network can be compensated for and also network throughput can be improved. Therefore, the client can receive a higher definition video. 
       SUMMARY 
       [0015]    As a client terminal uses a plurality of networks, energy consumption of the terminal increases compared to a case where the terminal uses only a single network. Further, the increase in the energy consumption of the terminal has a close relation with a provided video quality. 
         [0016]    Accordingly, the present disclosure provides an HTTP adaptive streaming method and apparatus for efficient energy consumption of the terminal in an environment in which a plurality of wireless networks are used. 
         [0017]    Further, the present disclosure provides a method and an apparatus for using an energy-image quality weighted value in consideration of a correlation between energy consumed by the terminal and the video quality of the provided video when a plurality of wireless networks are simultaneously used. 
         [0018]    In addition, the present disclosure provides a method and an apparatus for receiving a streaming service by adaptively controlling video quality while consuming a battery by an amount equal to or smaller than a target battery consumption amount set by the user. 
         [0019]    In accordance with an aspect of the present disclosure, a method of receiving a video segment from at least one streaming server by a client device using HTTP adaptive streaming in a wireless network is provided. The method includes: acquiring media presentation description (MPD) information by receiving an MPD file from the streaming server and parsing the received MPD file; determining a first parameter to minimize a cost function considering both energy consumption required for receiving a video segment and video quality of the video segment based on the MPD information; requesting at least one video segment to the at least one streaming server during a first segment request round based on the first parameter; and receiving the at least one video segment from the at least one streaming server. 
         [0020]    In accordance with another aspect of the present disclosure, a client device for receiving a video segment from at least one streaming server by using HTTP adaptive streaming in a wireless network is provided. The client device includes: a controller configured to acquire media presentation description (MPD) information by receiving an MPD file from the streaming server and parsing the received MPD file, determine a first parameter to minimize a cost function considering both energy consumption required for receiving a video segment and video quality of the video segment based on the MPD information, and request at least one video segment to the at least one streaming server during a first segment request round based on the first parameter, and receives the at least one video segment from the at least one streaming server; and a media play unit configured to play a video by using the received video segment. 
         [0021]    The present disclosure can provide a streaming service considering energy of a terminal when a plurality of networks are used through an HTTP adaptive streaming technology. 
         [0022]    The present disclosure can provide a seamless streaming service by selecting an optimal parameter according to an energy-video quality weighted value set by the user to the terminal using the HTTP adaptive streaming technology based on a wireless network environment. 
         [0023]    The present disclosure can provide a seamless streaming service while consuming a battery by an amount equal to or smaller than a target battery consumption amount set by the user. 
     
    
     
       BRIEF DESCRIPTION OF THE DRAWINGS 
         [0024]    The above and other aspects, features, and advantages of the present disclosure will be more apparent from the following detailed description taken in conjunction with the accompanying drawings, in which: 
           [0025]      FIG. 1  illustrates an example of structures of a server and a client that provide Dynamic Adaptive Streaming over HTTP (DASH) contents; 
           [0026]      FIG. 2  is a view conceptualizing an operation and a structure of a client terminal according to the present disclosure; 
           [0027]      FIG. 3  illustrates an example of segment request round(s) according to the present disclosure; 
           [0028]      FIG. 4  illustrates an example of parameters used by the terminal in the segment request round according to the present disclosure; 
           [0029]      FIG. 5  illustrates an example of an energy consumption pattern at a terminal side according to the present disclosure; 
           [0030]      FIGS. 6A and 6B  are flowcharts illustrating a method of determining a parameter by the client terminal according to the present disclosure; 
           [0031]      FIG. 7  illustrates an example of a user interface (UI) for setting target battery consumption provided by the terminal according to the present disclosure; 
           [0032]      FIG. 8  illustrates an example of another user interface (UI) for setting target battery consumption provided by the terminal according to the present disclosure; 
           [0033]      FIG. 9  illustrates a screen example for receiving target battery consumption provided by the terminal according to the present disclosure; 
           [0034]      FIG. 10  is a graph showing an adaptive operation result of an energy-video quality weighted value in a target battery consumption setting mode of the terminal according to the present disclosure; and 
           [0035]      FIG. 11  is a flowchart illustrating a method of operating the target battery consumption setting mode by using the parameter determination method by the terminal according to the present disclosure. 
       
    
    
     DETAILED DESCRIPTION 
       [0036]    Embodiments of the present disclosure will be described in detail with reference to the accompanying drawings. In the following description of the present disclosure, a detailed description of known configurations or functions incorporated herein will be omitted when it is determined that the detailed description may make the subject matter of the present disclosure unclear. The terms as described below are defined in consideration of the functions in the embodiments, and the meaning of the terms may vary according to the intention of a user or operator, convention, or the like. Accordingly, the terms should be defined based on the contents over the whole present specification. 
         [0037]    In the detailed description of the present disclosure, an example of interpretable meanings of some terms used in the present disclosure is proposed. However, it is noted that the terms are not limited to the examples of the construable meanings which are proposed below. 
         [0038]    A server may be referred to as a streaming server as a subject over a network that communicates with a client terminal to provide media data such as a video. 
         [0039]    A client terminal may be referred to as a terminal, a mobile terminal, a User Equipment (UE) terminal, a Mobile Station (MS), a Mobile Equipment (ME), a device, and the like as a subject that communicates with the server to receive media data, such as a video. 
         [0040]    The present disclosure will describe a client terminal that makes a request for a video segment to one or more wireless networks in consideration of a state of a wireless channel (that is, network path) and energy consumption of the terminal and receives the video segment. 
         [0041]      FIG. 2  is a view conceptualizing an operation and a structure of a client terminal according to the present disclosure. 
         [0042]    A client terminal apparatus according to the present disclosure may communicate with a streaming server through one or more networks  270 ,  272 , and  274 . The client terminal apparatus may include a controller  200  that communicates with the one or more networks  270 ,  272 , and  274  and a media play unit  260  that plays a video segment. The client terminal apparatus may be implemented in the form of a mobile terminal such as, for example, a smart phone and a smart pad. 
         [0043]    The controller  200  may include at least one of five main modules, that is, an HTTP client module  210 , a packet parser  220 , a network monitor  230 , a parameter control unit  240 , and a reordering unit  250 . The controller  200  may be analyzed as a subject that performs all operations of the terminal described below. 
         [0044]    The HTTP client module  210  may make a request for a Media Presentation Description (MPD) file, which corresponds to video metadata file, to the streaming server based on the HTTP. Further, the HTTP client module  210  may receive information from the parameter control unit  240  and the packet parser  220  and make a request for a video segment to the streaming server based on the information. 
         [0045]    The packet parser  220  may parse the MPD file received from the server, acquire MPD information or segment information from the MPD file, and provide the acquired MPD information to the HTTP client module  210  or provide the segment information to the parameter control unit  240 . Further, the packet parser  220  may receive segment data from the streaming server, identify the received segment data (that is, video segment), and transmit the segment data to the reordering unit  250 . The packet parser  220  may include at least one of an MPD parser  222  that parses the MPD file and a segment parser  224  that parses segment data. The packet parser  220  may further include a Transmission Control Protocol (TCP) reception buffer used for data reception. 
         [0046]    The network monitor  230  may monitor a state (for example, a network bandwidth and a delay state) of a network which can be used by the client terminal and predict a future state based on the monitored information. Further, the network monitor  230  may monitor and manage energy information (for example, an amount of consumption) according to the use of the wireless network by the client terminal. The network monitor  230  may include at least one of a transport layer unit  232  for monitoring a network and an energy unit  234  for monitoring consumed energy. 
         [0047]    The parameter control unit  240  may determine a parameter to be used for adaptive streaming based on information (for example, MPD information, network bandwidth bw, and a round trip time t rtt  according to each path during a segment request round (indicating a delay state)) received from the network monitor  230  or the packet parser  220 . The parameter determined by the parameter control unit  240  may include at least one of the number n seg  of segments requested for one segment request round, a time r rnd  of the segment request round, video quality q, and packet distribution matrix M information according to each network. The parameter control unit  240  may include at least one of a path selector  242  that determines a path according to each network, that is, a packet distribution matrix according to each network, and a segment determiner  244  that determines the number of segments, a segment request round time, and video quality. 
         [0048]    The reordering unit  250  may sequentially combine video segment data received from a plurality of wireless networks and transmit the sequentially combined segment data to an application buffer of the media play unit  260 . 
         [0049]    The media play unit  260  may serve to play media (for example, videos) by using segment data (for example, video segment data). The media play unit  260  may include a decoder and an application buffer. 
         [0050]      FIG. 3  illustrates an example of segment request round(s) according to the present disclosure. 
         [0051]    In adaptive streaming according to the present disclosure, one video may be divided in predetermined time units, and the videos divided in the time units correspond to segments. Further, there are a plurality of segments for a particular unit time according to video quality. That is, the video may be divided into segments of different video qualities. 
         [0052]    According to the present disclosure, an interval from a time point  300  when the client makes a request for a segment to the server to a time point  302  when the client makes a request for a next segment to the server is called a segment request round. An operation of the client according to the present disclosure may be performed in the unit of segment request rounds. 
         [0053]    As illustrated in  FIG. 3 , one segment request round may be divided into three intervals such as a request duration, a download duration, and a sleep duration. At a start point  300  of the request duration (RTT  1 , RTT  2 , and RTT  3 ), the client makes a request for a segment to the server. 
         [0054]    After the Round Trip Time (RTT) passes from the time point  300  when the client makes a request for the segment, the client starts receiving the requested segment. An interval in which the client receives (that is, downloads) the segment is referred to as the download duration  310 ,  312 ,  314 ,  316 ,  318 , and  320 . 
         [0055]    An interval in which the network is not used from a time point when the download of the segment ends to a time point when the segment request round ends is referred to as the sleep duration. 
         [0056]    During the segment request round, for example, four control parameters may be needed. The four control parameters may be determined when each segment request round starts. The four control parameters correspond to the number n seg  of segments, video quality q of the segment, a segment scheduling map M, and the segment request round t rnd . 
         [0057]    The client according to the present disclosure makes a request for a same quality video (that is, one video) during one segment request round. This is to provide video quality as stable as possible to the user. 
         [0058]    The client may receive one segment partitively through a plurality of networks in parallel during one segment request round. Due to the parallel reception of one segment, the client may acquire an effect of using a combined bandwidth of a plurality of wireless network bandwidth and make a request for a video of higher quality compared to a case where a single network is used. In addition, an out-of-order arrival problem of the data which may occur when the client makes a request for one segment to the single network may be reduced and, accordingly, seamless video play is possible. 
         [0059]    In adaptive streaming, the client may change video quality according to data throughput of the client. The client according to the present disclosure may calculate throughput computed according to the time through an exponential weighted moving average shown in equation (1) and predict a bandwidth available according to each wireless path. 
         [0000]        bw   i ( t )=α· r   i ( t )+(1−α)· bw   i ( t −1)   (1)
 
         [0000]    In equation (1), r i (t) denotes throughput predicted for an i th  network at time t, bw i (t) denotes an exponential weighted moving average of the throughput for the i th  network at time t, and α denotes a weighted value of the exponential weighted moving average and has a value from 0 to 1. 
         [0060]    Main parameters used in the present disclosure are shown in Table 1. 
         [0000]    
       
         
               
               
             
           
               
                 TABLE 1 
               
               
                   
               
               
                 Parameter 
                 Description 
               
               
                   
               
             
             
               
                 N net   
                 Number of network interfaces which can 
               
               
                   
                 be used by the client terminal 
               
               
                 N qlt   
                 Number of video quality levels which can 
               
               
                   
                 be provided by the server 
               
               
                 n seg   
                 Number of segments requested for one 
               
               
                   
                 segment request round 
               
               
                 q 
                 Segment video quality level 
               
               
                 v q   
                 Video bitrate (unit: kbps) of the segment 
               
               
                   
                 when the segment video quality level is q 
               
               
                 t rnd   
                 Segment request round time (unit: second) 
               
               
                 M 
                 Segment scheduling map 
               
               
                 {right arrow over (t)} rtt  = (t 1   rtt , t 2   rtt , . . . , t N     est     rtt ) 
                 Round Trip Time (RTT) according to each 
               
               
                   
                 path during segment request round 
               
               
                 {right arrow over (bw)} = (bw 1 , bw 2  . . . , bw N     est   ) 
                 Bandwidth according to each path during 
               
               
                   
                 segment request round 
               
               
                   
               
             
          
         
       
     
         [0061]    The segment request scheduling map M refers to a matrix including the number of packets requested according to each path for one segment request round and may be expressed as follows. 
         [0000]    
       
         
           
             
               
                 
                   M 
                   = 
                   
                     [ 
                     
                       
                         
                           
                             m 
                             
                               1 
                               , 
                               1 
                             
                           
                         
                         
                           
                             m 
                             
                               1 
                               , 
                               2 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             m 
                             
                               1 
                               , 
                               
                                 n 
                                 seg 
                               
                             
                           
                         
                       
                       
                         
                           
                             m 
                             
                               2 
                               , 
                               1 
                             
                           
                         
                         
                           
                             m 
                             
                               2 
                               , 
                               2 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             m 
                             
                               2 
                               , 
                               
                                 n 
                                 seg 
                               
                             
                           
                         
                       
                       
                         
                           ⋮ 
                         
                         
                           ⋮ 
                         
                         
                           ⋱ 
                         
                         
                           ⋮ 
                         
                       
                       
                         
                           
                             m 
                             
                               
                                 N 
                                 nat 
                               
                               , 
                               1 
                             
                           
                         
                         
                           
                             m 
                             
                               
                                 N 
                                 nat 
                               
                               , 
                               2 
                             
                           
                         
                         
                           … 
                         
                         
                           
                             m 
                             
                               
                                 N 
                                 nat 
                               
                               , 
                               
                                 n 
                                 seg 
                               
                             
                           
                         
                       
                     
                     ] 
                   
                 
               
               
                 
                   ( 
                   2 
                   ) 
                 
               
             
           
         
       
     
         [0062]    In the above matrix, m i,j  denotes an amount of data of a j th  segment (the number of packets) requested from the i th  network. 
         [0063]    The number of packets included in the j th  segment may be expressed as follows. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       ∑ 
                       
                         i 
                         = 
                         1 
                       
                       
                         N 
                         nat 
                       
                     
                      
                     
                       m 
                       
                         i 
                         , 
                         j 
                       
                     
                   
                   = 
                   
                     ⌈ 
                     
                       
                         s 
                         
                           j 
                           , 
                           q 
                         
                       
                       
                         P 
                         size 
                       
                     
                     ⌉ 
                   
                 
               
               
                 
                   ( 
                   3 
                   ) 
                 
               
             
           
         
       
     
         [0064]    In equation (3), S j,q  denotes the size of bytes of the j th  segment when a video quality level is q, and P size  denotes the size of a packet payload. 
         [0065]    At this time, a download time t i   down (M) of data downloaded through the i th  network is as follows. 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       t 
                       i 
                       down 
                     
                      
                     
                       ( 
                       M 
                       ) 
                     
                   
                   = 
                   
                     
                       
                         P 
                         size 
                       
                       · 
                       
                         
                           ∑ 
                           
                             j 
                             = 
                             1 
                           
                           
                             n 
                             seg 
                           
                         
                          
                         
                           m 
                           
                             i 
                             , 
                             j 
                           
                         
                       
                     
                     
                       bw 
                       i 
                     
                   
                 
               
               
                 
                   ( 
                   4 
                   ) 
                 
               
             
           
         
       
     
         [0066]      FIG. 4  illustrates an example of parameters used by the terminal in the segment request round according to the present disclosure. 
         [0067]    In a first segment request round (Round # 1 ) of  FIG. 4 , the terminal makes a request for two segments to three wireless networks. At this time, a length  400  of the first segment request round is expressed by a parameter t rnd . The number of segments requested by the terminal is expressed by a parameter n seg    410 . In the first segment request round, the video quality requested by the terminal is expressed by q  420 . The scheduling map M, which is a result of the scheduling by the terminal, may be expressed by parameters indicating the number of packets m 1,1    430 , m 1,2    432 , m 1,3    434 , and m 2,1    436 . 
         [0068]    As illustrated in  FIG. 4 , the length t rnd  of the segment request round, the number n seg  of requested segments, the video quality level of q the requested segment, and the segment request scheduling map M, corresponding to the parameters used in the present disclosure influence energy consumed by the client terminal, thereby having an effect on the user viewing a seamless high definition video. 
         [0069]    Hereinafter, an HTTP adaptive streaming scheme in which the client according to the present disclosure simultaneously considers energy and video quality in a heterogeneous wireless network environment and an efficient parameter determination scheme for the same will be described. 
         [0070]    That is, the efficient parameter determination to be described in the present disclosure may correspond to a matter for determining the length t rnd  of the segment request round that minimizes a cost function Ω(q,n seg ,M,t rnd ), the number of requested segments n seg , the video quality level q of the requested segment, and the segment request scheduling map M according to each path. The cost function Ω(q,n seg ,M,t rnd ) may be defined as equation (5). 
         [0000]    
       
         
           
             
               
                 
                   
                     λ 
                     · 
                     
                       
                         e 
                          
                         
                           ( 
                           
                             
                               n 
                               seg 
                             
                             , 
                             M 
                             , 
                             
                               t 
                               rnd 
                             
                           
                           ) 
                         
                       
                       
                         E 
                         seg 
                       
                     
                   
                   + 
                   
                     
                       ( 
                       
                         1 
                         - 
                         λ 
                       
                       ) 
                     
                     · 
                     
                       
                         d 
                          
                         
                           ( 
                           
                             v 
                             q 
                           
                           ) 
                         
                       
                       
                         D 
                         max 
                       
                     
                   
                 
               
               
                 
                   ( 
                   5 
                   ) 
                 
               
             
           
         
       
     
         [0071]    Equation (5) corresponds to a cost function calculated by normalizing each of energy consumption 
         [0000]    
       
         
           
             
               e 
                
               
                 ( 
                 
                   
                     n 
                     seg 
                   
                   , 
                   M 
                   , 
                   
                     t 
                     rnd 
                   
                 
                 ) 
               
             
             
               E 
               seg 
             
           
         
       
     
         [0000]    and video quality 
         [0000]    
       
         
           
             
               
                 d 
                  
                 
                   ( 
                   
                     v 
                     q 
                   
                   ) 
                 
               
               
                 D 
                 max 
               
             
             , 
           
         
       
     
         [0000]    and may give a weighted value to a preferred element by using an energy-video quality weighted value λ (lambda). λ has a value from 0 to 1. In equation (5), d(v q ) denotes an average distortion value for the requested segment quality and D max  denotes a maximum average distortion value for all segment qualities which can be provided by the server. 
         [0072]    At this time, equation (5) has constraints such as equations (6) to (9) below. 
         [0000]    
       
         
           
             
               
                 
                   
                     n 
                     seg 
                   
                   ≥ 
                   1 
                 
               
               
                 
                   ( 
                   6 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       
                         n 
                         seg 
                       
                     
                      
                     
                       s 
                       
                         j 
                         , 
                         q 
                       
                     
                   
                   ≤ 
                   
                     S 
                     buf 
                   
                 
               
               
                 
                   ( 
                   7 
                   ) 
                 
               
             
             
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           n 
                           seg 
                         
                         , 
                         M 
                         , 
                         
                           t 
                           rnd 
                         
                       
                       ) 
                     
                   
                   ≤ 
                   
                     E 
                     seg 
                   
                 
               
               
                 
                   ( 
                   8 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       max 
                       
                         1 
                         ≤ 
                         i 
                         ≤ 
                         
                           N 
                           net 
                         
                       
                     
                      
                     
                       { 
                       
                         
                           t 
                           i 
                           rtt 
                         
                         + 
                         
                           
                             t 
                             i 
                             down 
                           
                            
                           
                             ( 
                             M 
                             ) 
                           
                         
                       
                       } 
                     
                   
                   ≤ 
                   
                     χ 
                     · 
                     
                       t 
                       rnd 
                     
                   
                 
               
               
                 
                   ( 
                   9 
                   ) 
                 
               
             
           
         
       
     
         [0073]    Equation (6) shows that the number of segments requested by the client terminal is larger than or equal to 1. 
         [0074]    In equation (7), s j,q  denotes the size of the j th  segment of the video quality q. S buf  denotes the buffer size of the client terminal, and corresponds to a sum of the size of a TCP reception buffer and the size of an application buffer of the media play unit. Equation (7) corresponds to a condition to not increase an amount of energy consumption by making the size of segment data not larger than the buffer size of the terminal. 
         [0075]    In equation (8), e(n seg ,M,t rnd ) denotes average energy consumed per segment by the parameter for the segment request round, and E seg  denotes maximum energy consumed for one segment play time T seg . That is, equation (8) corresponds to a condition to make the average energy consumption per segment request round not exceed a limited maximum value. 
         [0076]    Equation (9) corresponds to a constraint to maintain a period of the segment request round longer than or equal to a predetermined size in order to not generate underflow (phenomenon corresponding to disconnection of a video since there is no data in the buffer) in the receiving side buffer (that is, buffer of the client terminal, and χ (chi) is a reference value from 0 to 1 to prevent buffer underflow. 
         [0077]    Subsequently, a method of calculating an amount of energy consumption for the segment request round to solve the parameter determination problem will be described. 
         [0078]    In order to determine the parameter, it is required to predict the amount of energy consumption of the client terminal according to the parameter. The present disclosure considers energy consumption at the client terminal side generated by the use of the wireless network and considers a simplified energy consumption pattern as illustrated in  FIG. 5  to solve the problem. 
         [0079]      FIG. 5  illustrates an example of an energy consumption pattern at the terminal side according to the present disclosure. 
         [0080]    An operation of the terminal during a time t rnd    530  spent for one segment request round is described with reference to  FIG. 5 . 
         [0081]    In a request duration  500 , the terminal makes a request for a segment to the server. At this time, the terminal consumes power to transmit data for the segment request. When a round trip time t i   rtt    540  of the terminal to the server is long enough, the network enters a tail state  542  and an idle state  544  before reception of the requested segment is received. 
         [0082]    When the terminal starts receiving the segment in earnest in a download duration  510 , power for segment data reception is consumed for a download time t i   rtt    550 . 
         [0083]    When the data reception ends, the terminal stays in the tail and idle states for a time t i   slp  in a sleep duration  520 . At this time, t i   tail  denotes a time for which the terminal stays in the tail state, which is differently set according to the wireless network I, and t i   idle  denotes a time for which a wireless interface between the terminal and the wireless network I stays in the idle state. They may be calculated as follows. 
         [0000]    
       
         
           
             
               
                 
                   
                     t 
                     i 
                     slp 
                   
                   = 
                   
                     
                       t 
                       rnd 
                     
                     - 
                     
                       t 
                       i 
                       rtt 
                     
                     - 
                     
                       
                         t 
                         i 
                         down 
                       
                        
                       
                         ( 
                         M 
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   10 
                   ) 
                 
               
             
             
               
                 
                   
                     t 
                     i 
                     tail 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               T 
                               i 
                               tail 
                             
                           
                           
                             
                               
                                 
                                   if 
                                    
                                   
                                       
                                   
                                    
                                   
                                     t 
                                     i 
                                     slp 
                                   
                                 
                                 ≥ 
                                 
                                   T 
                                   i 
                                   tail 
                                 
                               
                               , 
                             
                           
                         
                         
                           
                             
                               t 
                               i 
                               slp 
                             
                           
                           
                             otherwise 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   11 
                   ) 
                 
               
             
             
               
                 
                   
                     t 
                     i 
                     idle 
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               
                                 t 
                                 i 
                                 slp 
                               
                               - 
                               
                                 t 
                                 i 
                                 tail 
                               
                             
                           
                           
                             
                               
                                 
                                   if 
                                    
                                   
                                       
                                   
                                    
                                   
                                     t 
                                     i 
                                     slp 
                                   
                                 
                                 &gt; 
                                 
                                   t 
                                   i 
                                   tail 
                                 
                               
                               , 
                             
                           
                         
                         
                           
                             0 
                           
                           
                             otherwise 
                           
                         
                       
                       . 
                     
                   
                 
               
               
                 
                   ( 
                   12 
                   ) 
                 
               
             
           
         
       
     
         [0084]    In equation (11), T i   tail  denotes a tail time uniquely set at every wireless network i. For example, T i   tail  may have a value such as 200 msec in a case of Wi-Fi, and a value such as 10 sec in a case of LTE. When there is no data to be transmitted/received for the time T i   tail  after the client terminal has completed the data download with the wireless network I, the time t i   tail  for which the terminal actually stays in the tail state is same as the time T i   tail . However, when data transmission/reception re-starts within the time T i   tail  after the terminal has completed the data download, the t i   tail  for which the terminal stays in the tail state becomes the time t i   slp . 
         [0085]    Energy consumed when the terminal makes a request for the segment to the server is very small compared to energy consumed when the segment data is received. Accordingly, in the present disclosure, only the part for the reception of the segment data is considered as the energy consumption of the terminal. 
         [0086]    According to the present disclosure, it is assumed that the terminal has profiled power consumption information on each wireless network. At this time, the power consumption for each wireless network may be indicated by a data download power vector {right arrow over (p)} down , a tail power vector {right arrow over (p)} tail  of the sleep duration, and an idle power vector {right arrow over (p)} idle  of the sleep duration, and may be expressed by the following equations. 
         [0000]        {right arrow over (p)}   down   =p   1   down   ,p   2   down   , . . . ,p   N     net     down )   (13)
 
         [0000]        {right arrow over (p)}   tail   =p   1   tail   ,p   2   tail   , . . . ,p   N     net     tail )   (14)
 
         [0000]        {right arrow over (p)}   idle   =p   1   idle   ,p   2   idle   , . . . ,p   N     net     idle )   (15)
 
         [0087]    In equation (13), download power p i   down  of the i th  wireless network may be modeled by the following linear equation. 
         [0000]        p   i   down =β i   ·bw   i ( t )+γ i    (16)
 
         [0088]    In equation (16), β i  and γ i  denote modeling constants corresponding to the i th  wireless network. 
         [0089]    Through equation (16), average energy consumed per segment for the segment request round may be calculated as equation (17). 
         [0000]    
       
         
           
             
               
                 
                   
                     e 
                      
                     
                       ( 
                       
                         
                           n 
                           seg 
                         
                         , 
                         M 
                         , 
                         
                           t 
                           rnd 
                         
                       
                       ) 
                     
                   
                   = 
                   
                     
                       
                         1 
                         
                           n 
                           seg 
                         
                       
                        
                       
                         
                           ∑ 
                           
                             i 
                             = 
                             1 
                           
                           N 
                         
                          
                         
                           { 
                           
                             
                               
                                 p 
                                 i 
                                 down 
                               
                               · 
                               
                                 
                                   t 
                                   i 
                                   down 
                                 
                                  
                                 
                                   ( 
                                   M 
                                   ) 
                                 
                               
                             
                             + 
                             
                               
                                 p 
                                 i 
                                 tail 
                               
                               · 
                               
                                 t 
                                 i 
                                 tail 
                               
                             
                             + 
                             
                               
                                 p 
                                 i 
                                 idle 
                               
                               · 
                               
                                 t 
                                 i 
                                 idle 
                               
                             
                           
                           } 
                         
                       
                     
                     + 
                     
                       
                         p 
                         base 
                       
                       · 
                       
                         ( 
                         
                           
                             t 
                             1 
                             down 
                           
                           + 
                           
                             t 
                             1 
                             slp 
                           
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   17 
                   ) 
                 
               
             
           
         
       
     
         [0090]    Subsequently, a method of calculating a distortion value for the segment request round to solve the parameter determination problem will be described. 
         [0091]    The present disclosure uses an average distortion value of the video as a scale of video quality. In general, as a code rate is higher, distortion becomes smaller. According to the present disclosure, the client terminal may use the following two methods to know an average distortion value of the video. 
         [0092]    In a first method, the streaming server provides the average distortion value of the video. The streaming server may transcode an original video for the HTTP adaptive streaming service and, at this time, calculate the average distortion value of the video. The streaming server may record the calculated average distortion value in an MPD file to inform the client terminal of the average distortion value. In a case of the DASH standard, the streaming server may provide a distortion value of the video by using an attribute value “@qualityRanking” of the MPD file. The attribute “@qualityRanking” corresponds to a selective attribute of a DASH representation element, and means higher video quality as a value thereof becomes smaller. 
         [0093]    In a second method, when the streaming server cannot provide the average distortion value of the video, the client terminal predicts the distortion value of the video by using an estimation module implemented in the inside. At this time, the client terminal may predict the average distortion value of the video without the original video by using a scheme such as a no-reference video quality estimation model. 
         [0094]    In order to acquire an optimal solution of the parameter determination problem, the client terminal according to the present disclosure may use a full-search based algorithm. In this case, the parameter determination algorithm according to the present disclosure may have complexity of O(N qlt ·N seg   max ·Π i=1   N     net   m i   net ). In the complexity, N seg   max  denotes a maximum number of segments which can be requested by the terminal for one segment request round and may be preset as a predetermined value. At this time, m i   max   _   net (n seg   new ) denotes a maximum number of allowable packets of the network i. 
         [0095]    The complexity is proportional to the number N qlt  of video qualities which can be provided by the server and the number N net  of wireless networks which can be used by the client terminal. However, in the actual HTTP adaptive streaming service, the size of N qlt  is typically limited to be within 10, and the size of N net  also typically has a limited value such as 2 to 3. If a mobile terminal can use only two networks, Wi-Fi and LTE, the complexity of the parameter determination algorithm according to the present disclosure is simplified as 
         [0000]    
       
         
           
             
               O 
                
               
                 ( 
                 
                   
                     N 
                     qlt 
                   
                   · 
                   
                     N 
                     seg 
                     max 
                   
                   · 
                   
                     
                       max 
                       
                         1 
                         ≤ 
                         i 
                         ≤ 
                         2 
                       
                     
                      
                     
                       { 
                       
                         
                           m 
                           i 
                           max_net 
                         
                          
                         
                           ( 
                           
                             n 
                             seg 
                             new 
                           
                           ) 
                         
                       
                       } 
                     
                   
                 
                 ) 
               
             
             , 
           
         
       
     
         [0000]    and the simplified complexity can be actually calculated by the client terminal. 
         [0096]      FIGS. 6A and 6B  are flowcharts illustrating a method of determining a parameter by the client terminal according to the present disclosure. The terminal initializes various parameters and initializes a cost function as shown in equation (18) in step  600 . 
         [0000]      Ω( q   cur   ,n   seg   cur   ,M   cur   ,t   rnd   cur )=∞   (18)
 
         [0097]    The terminal re-arranges sequences of wireless networks in an ascending order of download power p i   down  in step  602 . The re-arranging operation  602  may be performed prior to the cost function initialization operation  600 . 
         [0098]    The terminal calculates a maximum value n q   max   _   seg  of the number of requested segments for the segment video quality q as shown in equations (19) and (20) in step  604 . 
         [0000]    
       
         
           
             
               
                 
                   
                     
                       t 
                       q 
                       rnd 
                     
                      
                     
                       ( 
                       n 
                       ) 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             
                               χ 
                               · 
                               
                                 ( 
                                 
                                   
                                     t 
                                     buf 
                                   
                                   + 
                                   
                                     T 
                                     seg 
                                   
                                 
                                 ) 
                               
                             
                             + 
                             
                               
                                 ( 
                                 
                                   n 
                                   - 
                                   1 
                                 
                                 ) 
                               
                               · 
                               
                                 T 
                                 seg 
                               
                             
                           
                         
                         
                           
                             
                               
                                 if 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     t 
                                     q 
                                     rnd 
                                   
                                    
                                   
                                     ( 
                                     n 
                                     ) 
                                   
                                 
                               
                               ≥ 
                               
                                 
                                   ∑ 
                                   
                                     j 
                                     = 
                                     1 
                                   
                                   n 
                                 
                                  
                                 
                                   
                                     s 
                                     
                                       j 
                                       , 
                                       q 
                                     
                                   
                                   / 
                                   
                                     
                                       ∑ 
                                       
                                         i 
                                         = 
                                         1 
                                       
                                       
                                         N 
                                         net 
                                       
                                     
                                      
                                     
                                       bw 
                                       i 
                                     
                                   
                                 
                               
                             
                             , 
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             
                               
                                 
                                   t 
                                   q 
                                   rnd 
                                 
                                  
                                 
                                   ( 
                                   n 
                                   ) 
                                 
                               
                               ≤ 
                               
                                 
                                   t 
                                   buf 
                                 
                                 + 
                                 
                                   n 
                                   · 
                                   
                                     T 
                                     seg 
                                   
                                 
                                 - 
                                 
                                   T 
                                   max 
                                 
                               
                             
                             , 
                           
                         
                       
                       
                         
                           
                               
                           
                         
                         
                           
                             
                               
                                 and 
                                  
                                 
                                     
                                 
                                  
                                 
                                   
                                     ∑ 
                                     
                                       j 
                                       = 
                                       1 
                                     
                                     
                                       n 
                                       seg 
                                     
                                   
                                    
                                   
                                     s 
                                     
                                       j 
                                       , 
                                       q 
                                     
                                   
                                 
                               
                               ≤ 
                               
                                 S 
                                 buf 
                               
                             
                             , 
                           
                         
                       
                       
                         
                           0 
                         
                         
                           otherwise 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   19 
                   ) 
                 
               
             
             
               
                 
                   
                       
                   
                    
                   
                     
                       n 
                       q 
                       max_seg 
                     
                     = 
                     
                       arg 
                        
                       
                           
                       
                        
                       
                         
                           max 
                           
                             1 
                             ≤ 
                             n 
                             ≤ 
                             
                               N 
                               max_seg 
                             
                           
                         
                          
                         
                           { 
                           
                             
                               t 
                               q 
                               rnd 
                             
                              
                             
                               ( 
                               n 
                               ) 
                             
                           
                           } 
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   20 
                   ) 
                 
               
             
           
         
       
     
         [0099]    In equation (19), t buf  denotes a playable time of video data in an application buffer at a time point when the segment request round starts, S buf  denotes a sum of the size of the TCP reception buffer and the size of the application buffer, and T seg  denotes one segment play time. 
         [0100]    In equation (20), N max   _   seg  denotes a maximum number of segments which can be requested for the segment request round. 
         [0101]    The terminal generates a combination (q new ,n seg   new ) (1≦q new ≦q max  and 1≦n seg   new ≦n q     new     max   _   seg ) of the number N max   _   seg  of allowable requested segments for all segment video qualities N max   _   seg  in step  606 . 
         [0102]    The terminal selects one combination from the generated combinations and calculates tot a total number m tot  of packets to be received for the selected combination, a segment request round time t rnd   new , and a maximum number of allowable packets according to each network m i   max   _   net (n seg   new ) as shown in equations (21) and (23) in step  608 . 
         [0000]    
       
         
           
             
               
                 
                   
                     m 
                     tot 
                   
                   = 
                   
                     
                       ∑ 
                       
                         j 
                         = 
                         1 
                       
                       
                         n 
                         seg 
                         new 
                       
                     
                      
                     
                       ⌈ 
                       
                         
                           s 
                           
                             j 
                             , 
                             
                               q 
                               new 
                             
                           
                         
                         
                           P 
                           size 
                         
                       
                       ⌉ 
                     
                   
                 
               
               
                 
                   ( 
                   21 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       t 
                       rnd 
                       new 
                     
                      
                     
                       ( 
                       
                         n 
                         seg 
                         new 
                       
                       ) 
                     
                   
                   = 
                   
                     
                       χ 
                       · 
                       
                         ( 
                         
                           
                             t 
                             buf 
                           
                           + 
                           
                             T 
                             seg 
                           
                         
                         ) 
                       
                     
                     + 
                     
                       
                         ( 
                         
                           
                             n 
                             seg 
                             new 
                           
                           - 
                           1 
                         
                         ) 
                       
                       · 
                       
                         T 
                         seg 
                       
                     
                   
                 
               
               
                 
                   ( 
                   22 
                   ) 
                 
               
             
             
               
                 
                   
                     
                       m 
                       i 
                       max_net 
                     
                      
                     
                       ( 
                       
                         n 
                         seg 
                         new 
                       
                       ) 
                     
                   
                   = 
                   
                     ⌈ 
                     
                       
                         
                           { 
                           
                             
                               
                                 t 
                                 rnd 
                                 new 
                               
                                
                               
                                 ( 
                                 
                                   n 
                                   seg 
                                   new 
                                 
                                 ) 
                               
                             
                             - 
                             
                               t 
                               i 
                               rtt 
                             
                           
                           } 
                         
                         · 
                         
                           bw 
                           i 
                         
                       
                       
                         P 
                         size 
                       
                     
                     ⌉ 
                   
                 
               
               
                 
                   ( 
                   23 
                   ) 
                 
               
             
           
         
       
     
         [0103]    The terminal generates all allowable combinations (m 1   net , m 2   net , - - - , m N     net     net ) which meet equation (24) to consider the number m i   net  of packets received in each network in step  610 . 
         [0000]    
       
         
           
             
               
                 
                   
                     m 
                     tot 
                   
                   = 
                   
                     
                       
                         ∑ 
                         
                           i 
                           = 
                           1 
                         
                         
                           N 
                           net 
                         
                       
                        
                       
                         
                           m 
                           i 
                           net 
                         
                          
                         
                             
                         
                          
                         for 
                          
                         
                             
                         
                          
                         0 
                       
                     
                     ≤ 
                     
                       m 
                       i 
                       net 
                     
                     ≤ 
                     
                       
                         m 
                         i 
                         max_net 
                       
                        
                       
                         ( 
                         
                           n 
                           seg 
                           new 
                         
                         ) 
                       
                     
                   
                 
               
               
                 
                   ( 
                   24 
                   ) 
                 
               
             
           
         
       
     
         [0104]    The terminal may select one combination from the generated combinations (m 1   net , m 2   net , - - - , m N     net     net ) and calculate a data amount (number of packets) m i,j  of the j th  segment requested from the i th  network for the selected combination in step  612 . 
         [0000]    
       
         
           
             
               
                 
                   
                     m 
                     
                       i 
                       , 
                       j 
                     
                   
                   = 
                   
                     { 
                     
                       
                         
                           
                             ⌊ 
                             
                               
                                 ⌈ 
                                 
                                   
                                     s 
                                     
                                       j 
                                       , 
                                       q 
                                     
                                   
                                   
                                     P 
                                     size 
                                   
                                 
                                 ⌉ 
                               
                               × 
                               
                                 
                                   m 
                                   i 
                                   net 
                                 
                                 
                                   m 
                                   tot 
                                 
                               
                             
                             ⌋ 
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               i 
                             
                             &lt; 
                             
                               
                                 N 
                                 net 
                               
                                
                               
                                   
                               
                                
                               and 
                                
                               
                                   
                               
                                
                               j 
                             
                             &lt; 
                             
                               n 
                               seg 
                             
                           
                         
                       
                       
                         
                           
                             
                               m 
                               i 
                               net 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   k 
                                   = 
                                   1 
                                 
                                 
                                   j 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 m 
                                 
                                   i 
                                   , 
                                   k 
                                 
                               
                             
                           
                         
                         
                           
                             
                               
                                 if 
                                  
                                 
                                     
                                 
                                  
                                 i 
                               
                               &lt; 
                               
                                 
                                   N 
                                   net 
                                 
                                  
                                 
                                     
                                 
                                  
                                 and 
                                  
                                 
                                     
                                 
                                  
                                 j 
                               
                             
                             = 
                             
                               n 
                               seg 
                             
                           
                         
                       
                       
                         
                           
                             
                               ⌈ 
                               
                                 
                                   s 
                                   
                                     j 
                                     , 
                                     q 
                                   
                                 
                                 
                                   P 
                                   size 
                                 
                               
                               ⌉ 
                             
                             - 
                             
                               
                                 ∑ 
                                 
                                   k 
                                   = 
                                   1 
                                 
                                 
                                   i 
                                   - 
                                   1 
                                 
                               
                                
                               
                                 m 
                                 
                                   k 
                                   , 
                                   j 
                                 
                               
                             
                           
                         
                         
                           
                             
                               if 
                                
                               
                                   
                               
                                
                               i 
                             
                             = 
                             
                               N 
                               net 
                             
                           
                         
                       
                     
                   
                 
               
               
                 
                   ( 
                   25 
                   ) 
                 
               
             
           
         
       
     
         [0105]    The terminal calculates a cost function Ω(q new ,n seg   new ,M new ,t rnd   new ) by using the calculated m i,j  in step  614 . 
         [0106]    In step  616 , the terminal compares a value of the minimum cost function Ω(q cur ,n seg   cur ,M cur ,t rnt   cur ) calculated up to now with a value of the new cost function Ω(q new ,n seg   new ,M new ,t rnd   new ) calculated in step  614 . 
         [0107]    When the value of new cost function Ω(q cur ,n seg   cur ,M cur ,t rnt   cur ) calculated in step  614  is smaller than the value of the current minimum cost function Ω(q new ,n seg   new ,M new ,t rnd   new ), the terminal updates the value of the current minimum cost function Ω(q cur ,n seg   cur ,M cur ,t rnt   cur ) to the value of the new cost function function Ω(q new ,n seg   new ,M new ,t rnd   new ) in step  618 . 
         [0108]    The terminal inspects whether there is the combination (m 1   net , m 2   net , - - - , m N     net     net ) which has not been yet checked in step  620 . When there is the combination (m 1   net , m 2   net , - - - , m N     net     net ) which has not been checked, the terminal may perform step  612  again and the following operations. 
         [0109]    The terminal inspects whether there is the combination (q new ,n seg   new ) which has not been yet checked in step  622 . When there is the combination (q new ,n seg   new ) which has not been checked, the terminal may perform step  608  again and the following operations. 
         [0110]    The terminal determines the value of the current cost function Ω(q cur ,n seg   cur ,M cur ,t rnt   cur ) as the optimal solution as shown in equation (26) in step  624  after performing the above operations. 
         [0000]      ( q   opt   ,n   seg   opt   ,M   cur   ,t   rnd   cur )=( q   cur   ,n   seg   cur   ,M   cur   ,t   rnd   cur )   (26)
 
         [0111]    The client terminal according to the present disclosure may give a weighted value to a preferred element between consumed energy and video quality by using the energy-video quality weighted value λ. Parameters determined according to different energy-video quality weighted values have different tendencies. 
         [0112]    As described above, the consumed energy and the video quality of the terminal have a close relation. For example, to support high video quality, much energy is consumed. Accordingly, in order to reduce energy consumption of the terminal, it is required to reduce video quality. Further, in order to increase video quality, it is required to increase energy consumption of the terminal. 
         [0113]    For example, according to the present disclosure, the energy-video quality weighted value may be set by a “target battery consumption setting mode” user interface (UI). 
         [0114]      FIG. 7  illustrates an example of a UI for setting target battery consumption provided by the terminal according to the present disclosure. A case where the target battery consumption setting mode is deactivated will be described with reference to  FIG. 7 . The case where the target battery consumption setting mode is deactivated corresponds to a case where a fixed energy-video quality weighted value is used. 
         [0115]    When the user deactivates the “target battery consumption setting” mode by selecting the “target battery consumption setting” as “off”  700 , the energy-video quality weighted value λ may be set by a user&#39;s preference. As illustrated in  FIG. 7 , the user may determine the energy-video quality weighted value as a value from 0 to 100 by selecting a predetermined position on a level selection bar  710 . As the value selected by the user is closer to “video quality” (that is, video quality 100%), the energy-video quality weighted value λ becomes closer to 0 and thus weighs the video quality more heavily. In contrast, as the value selected by the user is closer to the “battery” (that is, video quality 0%), the energy-video quality weighted value λ becomes closer to 1 and thus weighs consumed energy more heavily than the video quality, thereby further reducing battery consumption of the client terminal. 
         [0116]      FIG. 8  illustrates an example of another user interface (UI) for setting target battery consumption provided by the terminal according to the present disclosure. A case where the target battery consumption setting mode is activated will be described with reference to  FIG. 8 . The case where the target battery consumption setting mode is activated corresponds to a case where an adaptive energy-video quality weighted value is used. 
         [0117]    When the user activates the “target battery consumption setting” mode by selecting the “target battery consumption setting” as “on”  800 , the energy-video quality weighted value may be adaptively determined to be close to the target battery consumption set by the user. That is, when the “target battery consumption setting” is selected as “on”  800 , a level selection bar  810  to receive the energy-video quality weighted value may be deactivated and the terminal may output a separate UI for receiving the target battery consumption. 
         [0118]      FIG. 9  illustrates a screen example for receiving target battery consumption provided by the terminal according to the present disclosure. The user may select the target battery consumption by selecting a predetermined position on a state selection bar  910 . According to a user&#39;s input on the state selection bar  910 , the terminal may output corresponding target battery consumption  900  and corresponding average video quality  920  on the screen as numerical values. 
         [0119]    The terminal having received the target battery consumption adaptively controls video quality not to exceed the target battery consumption until video play ends. 
         [0120]    Meanwhile, when the terminal exceeds expected battery consumption by a particular reason such as a bad network state, the terminal may output an additional user interface (UI) (for example, as illustrated in  FIG. 9 ) to receive a re-input of the target battery consumption from the user in a popup form. 
         [0121]      FIG. 10  is a graph showing an adaptive operation result of the energy-video quality weighted value in the target battery consumption setting mode of the terminal according to the present disclosure. 
         [0122]    The terminal which determines that energy consumption measured at a time point  1000  when segment request round # 1  ends is smaller than target energy consumption reduces the energy-video quality weighted value λ to request and play a high video quality segment. 
         [0123]    The terminal which determines that energy consumption measured at a time point  1002  when segment request round # 2  ends is larger than the target energy consumption increases the energy-video quality weighted value λ to request and play a low video quality segment. 
         [0124]    The terminal which determines that energy consumption measured at a time point  1004  when segment request round # 3  ends is still larger than the target energy consumption increases the energy-video quality weighted value λ to request and play a low video quality segment. 
         [0125]    The terminal which determines that energy consumption measured at a time point  1006  when segment request round # 4  ends is smaller than the target energy consumption reduces the energy-video quality weighted value λ to request and play a high video quality segment. 
         [0126]    Through such an operation, the terminal may allow energy consumption measured at a time point  1008  when segment request round # 5  ends to come close to the target energy consumption. 
         [0127]      FIG. 11  is a flowchart illustrating a method of operating the target battery consumption setting mode by using the parameter determination method by the terminal according to the present disclosure. 
         [0128]    A method of adaptively changing the energy-video quality weighted value when the target battery consumption setting mode is activated will be described with reference to  FIG. 11 . 
         [0129]    The client terminal receives an MPD file from the streaming server before playing a video and parses the MPD file to acquire MPD information in step  1100 . 
         [0130]    The terminal updates energy information required for monitoring a network path and playing the video based on the acquired MPD information in step  1102 . The energy information may include minimum energy consumption E min   target  and maximum energy consumption E max   target . 
         [0131]    The terminal may determine whether the target battery consumption setting mode is activated in step  1104 . When the target battery consumption setting mode is activated, the terminal may check whether a current segment request round is an initial segment request round or battery consumption exceeds target battery consumption in step  1106 . 
         [0132]    When the current segment request round is the initial round or when the battery consumption exceeds the target battery consumption, the terminal may provide the level selection bar  910  having values between the maximum/minimum energy consumption E min   target  and E maz   target  for video play as illustrated in  FIG. 9  and receive one of the values between E min   target  and E max   target  as the target battery consumption E target  from the user in step  1108 . 
         [0133]    E min   target  and E max   target  may be calculated based on equations below. 
         [0000]        E   min   target   =E   min   seg   ·N   tot   seg    (27)
 
         [0000]        E   max   target   =E   max   seg   ·N   tot   seg    (28)
 
         [0134]    In equations (27) and (28), E min   seg  and E max   seg  denote minimum energy and maximum energy which may be consumed by one segment, respectively, and N tot   seg  denotes a total number of segments required for a total video play time. 
         [0135]    At this time, E min   seg  and E max   seg  may be calculated based on equations below. 
         [0000]        E   min   seg =( p   base   +p   1   down )· T   seg    (29)
 
         [0000]        E   max   seg =( p   base +Σ i=1   N     net     p   i   down )· T   seg    (30)
 
         [0136]    In equation (29), E min   seg  denotes energy when data is received from T seg  by using only a network which consumes smallest power. 
         [0137]    In equation (30), E max   seg  denotes energy when data is received for T seg  by using all networks. 
         [0138]    E target  selected by the user has a relation as shown in equation (31). 
         [0000]        E   target   =E   seg   ·N   tot   seg    (31)
 
         [0139]    The terminal updates the energy-video quality weighted value λ by using E target  in step  1110 . 
         [0140]    More specifically, the terminal may control the energy-video quality weighted value λ to make actual battery consumption come closer to the target battery consumption as illustrated in  FIG. 10  until the video play ends. At this time, a real-time energy-video quality weighted value control algorithm used by the terminal may be expressed by, for example, equations below. 
         [0000]    
       
         
           
             
               
                 
                   
                     λ 
                     
                       k 
                       + 
                       1 
                     
                   
                   = 
                   
                     
                       λ 
                       k 
                     
                     + 
                     
                       Δ 
                        
                       
                           
                       
                        
                       
                         λ 
                         k 
                       
                     
                   
                 
               
               
                 
                   ( 
                   32 
                   ) 
                 
               
             
             
               
                 
                   
                     Δ 
                      
                     
                         
                     
                      
                     
                       λ 
                       k 
                     
                   
                   = 
                   
                     
                       
                         E 
                         k 
                       
                       
                         E 
                         k 
                         target 
                       
                     
                     - 
                     1 
                   
                 
               
               
                 
                   ( 
                   33 
                   ) 
                 
               
             
             
               
                 
                   
                     E 
                     k 
                     target 
                   
                   = 
                   
                     
                       
                         E 
                         seg 
                       
                       · 
                       
                         n 
                         seg 
                       
                     
                     + 
                     
                       E 
                       
                         k 
                         - 
                         1 
                       
                       target 
                     
                     - 
                     
                       E 
                       
                         k 
                         - 
                         1 
                       
                     
                   
                 
               
               
                 
                   ( 
                   34 
                   ) 
                 
               
             
           
         
       
     
         [0141]    In the above equations, λ k  denotes an energy-video quality weighted value for a k th  segment request round. E k  denotes actual battery consumption measured for the k th  segment request round and E k   target  denotes target energy consumption of the k th  segment request round. 
         [0142]    The terminal determines parameters q, n seg , M, and t rnd  which minimize a cost function by using the updated weighted value λ in step  1112 . 
         [0143]    The terminal makes a request for a segment by using the determined parameters in step  1114 . The terminal may download the requested segment in step  1116 , and play the downloaded segment. Additionally, the terminal may check whether the video ends based on the current segment in step  1118 , and end an adaptive streaming operation according to a result of the check. 
         [0144]    It is noted that the view illustrating the configuration of the terminal apparatus, the view illustrating the segment request round, the parameter determination method of the terminal, and the UI provided by the terminal, illustrated in  FIGS. 2 through 11  do not have an intention to limit the claim of the present disclosure. That is, all components, steps of all operations, and all UI elements illustrated in  FIGS. 2 through 11  should not be construed as necessary components for implementing the present disclosure, and the present disclosure can be implemented only by some of the components without departing from the scope of the present disclosure. 
         [0145]    The above described operations may be implemented by providing a memory device storing a corresponding program code to any constituent unit in a smart module or a device. That is, the controller of the smart module or device may perform the above described operations by reading and executing the program code stored in the memory device by means of a processor or a central processing unit (CPU). 
         [0146]    The various components of the smart module, device and the like used in the specification may operate by using a hardware circuit, for example, a combination of a complementary metal oxide semiconductor based logical circuit, firmware, software and/or hardware, and a combination of firmware and/or software inserted into a machine-readable medium. As an example, various electric configurations and methods may be carried out by using electric circuits such as transistors, logic gates, and an application specific integrated circuit (ASIC). 
         [0147]    While the present disclosure has been shown and described with reference to certain embodiments thereof, it will be understood by those skilled in the art that various changes in form and details may be made therein without departing from the scope of the present disclosure. Therefore, the scope of the present disclosure should not be defined as being limited to the embodiments, but should be defined by the appended claims and equivalents thereof.