Home | History | Annotate | Download | only in bitstreams 
      1 /*
      2  * Copyright (C) 2017 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package android.media.cts.bitstreams;
     18 
     19 import com.android.tradefed.device.DeviceNotAvailableException;
     20 import com.android.tradefed.device.ITestDevice;
     21 import com.android.tradefed.log.LogUtil.CLog;
     22 import java.util.Collections;
     23 import java.util.HashMap;
     24 import java.util.LinkedHashSet;
     25 import java.util.Map;
     26 import java.util.Set;
     27 
     28 /**
     29  * Runs a test on target device to query support for bitstreams listed in device side
     30  * dynamic configuration file.
     31  */
     32 public class SupportedBitstreamsProcessor extends ReportProcessor {
     33 
     34     private final String mPrefix;
     35     private final boolean mDebugTargetDevice;
     36     private final Set<String> mSupportedBitstreams = new LinkedHashSet<>();
     37     private final Map<String, Map<String, Boolean>> mDecodersForPath = new HashMap<>();
     38 
     39     public SupportedBitstreamsProcessor() {
     40         this("",false);
     41     }
     42 
     43     /**
     44      * @param prefix only bitstreams whose relative paths start with {@code prefix}
     45      * would be processed
     46      * @param debugTargetDevice whether to pause {@code device} for debugging
     47      */
     48     public SupportedBitstreamsProcessor(String prefix, boolean debugTargetDevice) {
     49         mPrefix = prefix;
     50         mDebugTargetDevice = debugTargetDevice;
     51     }
     52 
     53     /**
     54      * @return paths to bitstreams that are supported on device
     55      */
     56     public Set<String> getSupportedBitstreams() {
     57         return mSupportedBitstreams;
     58     }
     59 
     60     /**
     61      * @return paths to all bitstreams whose relative paths start with <code>prefix</code>
     62      */
     63     public Set<String> getBitstreams() {
     64         return mDecodersForPath.keySet();
     65     }
     66 
     67     public Map<String, Boolean> getDecoderCapabilitiesForPath(String path) {
     68         if (mDecodersForPath.containsKey(path)) {
     69             return mDecodersForPath.get(path);
     70         }
     71         return Collections.emptyMap();
     72     }
     73 
     74     @Override
     75     Map<String, String> getArgs() {
     76         Map<String, String> args = new HashMap<>();
     77         args.put(MediaBitstreams.OPT_BITSTREAMS_PREFIX, mPrefix);
     78         args.put(MediaBitstreams.OPT_DEBUG_TARGET_DEVICE, Boolean.toString(mDebugTargetDevice));
     79         return args;
     80     }
     81 
     82     @Override
     83     void process(ITestDevice device, String reportPath) throws DeviceNotAvailableException {
     84         mSupportedBitstreams.clear();
     85         String[] lines = getReportLines(device, reportPath);
     86         try {
     87             for (int i = 0; i < lines.length;) {
     88                 String path = lines[i++];
     89                 int n = Integer.parseInt(lines[i++]);
     90                 for (int j = 0; j < n; j++) {
     91                     String name = lines[i++];
     92                     String status = lines[i++];
     93                     boolean supported = status.equals("true");
     94                     if (supported) {
     95                         mSupportedBitstreams.add(path);
     96                     }
     97                     Map<String, Boolean> decoderCapabilities;
     98                     if (mDecodersForPath.containsKey(path)) {
     99                         decoderCapabilities = mDecodersForPath.get(path);
    100                     } else {
    101                         mDecodersForPath.put(path, decoderCapabilities = new HashMap<>());
    102                     }
    103                     decoderCapabilities.put(name, supported);
    104                 }
    105             }
    106         } catch (Exception e) {
    107             CLog.w(e);
    108         }
    109     }
    110 
    111 }
    112