Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  1. /*
  2.  * DirectShow capture interface
  3.  * Copyright (c) 2015 Roger Pack
  4.  *
  5.  * This file is part of FFmpeg.
  6.  *
  7.  * FFmpeg is free software; you can redistribute it and/or
  8.  * modify it under the terms of the GNU Lesser General Public
  9.  * License as published by the Free Software Foundation; either
  10.  * version 2.1 of the License, or (at your option) any later version.
  11.  *
  12.  * FFmpeg is distributed in the hope that it will be useful,
  13.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15.  * Lesser General Public License for more details.
  16.  *
  17.  * You should have received a copy of the GNU Lesser General Public
  18.  * License along with FFmpeg; if not, write to the Free Software
  19.  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  20.  */
  21.  
  22. #include "dshow_capture.h"
  23.  
  24. static const char *
  25. GetPhysicalPinName(long pin_type)
  26. {
  27.     switch (pin_type)
  28.     {
  29.     case PhysConn_Video_Tuner:            return "Video Tuner";
  30.     case PhysConn_Video_Composite:        return "Video Composite";
  31.     case PhysConn_Video_SVideo:           return "S-Video";
  32.     case PhysConn_Video_RGB:              return "Video RGB";
  33.     case PhysConn_Video_YRYBY:            return "Video YRYBY";
  34.     case PhysConn_Video_SerialDigital:    return "Video Serial Digital";
  35.     case PhysConn_Video_ParallelDigital:  return "Video Parallel Digital";
  36.     case PhysConn_Video_SCSI:             return "Video SCSI";
  37.     case PhysConn_Video_AUX:              return "Video AUX";
  38.     case PhysConn_Video_1394:             return "Video 1394";
  39.     case PhysConn_Video_USB:              return "Video USB";
  40.     case PhysConn_Video_VideoDecoder:     return "Video Decoder";
  41.     case PhysConn_Video_VideoEncoder:     return "Video Encoder";
  42.  
  43.     case PhysConn_Audio_Tuner:            return "Audio Tuner";
  44.     case PhysConn_Audio_Line:             return "Audio Line";
  45.     case PhysConn_Audio_Mic:              return "Audio Microphone";
  46.     case PhysConn_Audio_AESDigital:       return "Audio AES/EBU Digital";
  47.     case PhysConn_Audio_SPDIFDigital:     return "Audio S/PDIF";
  48.     case PhysConn_Audio_SCSI:             return "Audio SCSI";
  49.     case PhysConn_Audio_AUX:              return "Audio AUX";
  50.     case PhysConn_Audio_1394:             return "Audio 1394";
  51.     case PhysConn_Audio_USB:              return "Audio USB";
  52.     case PhysConn_Audio_AudioDecoder:     return "Audio Decoder";
  53.     default:                              return "Unknown Crossbar Pin Type—Please report!";
  54.     }
  55. }
  56.  
  57. static HRESULT
  58. setup_crossbar_options(IAMCrossbar *cross_bar, enum dshowDeviceType devtype, AVFormatContext *avctx)
  59. {
  60.     struct dshow_ctx *ctx = avctx->priv_data;
  61.     long count_output_pins, count_input_pins;
  62.     int i;
  63.     int log_level = ctx->list_options ? AV_LOG_INFO : AV_LOG_DEBUG;
  64.     int video_input_pin = ctx->crossbar_video_input_pin_number;
  65.     int audio_input_pin = ctx->crossbar_audio_input_pin_number;
  66.     const char *device_name = ctx->device_name[devtype];
  67.     HRESULT hr;
  68.  
  69.     av_log(avctx, log_level, "Crossbar Switching Information for %s:\n", device_name);
  70.     hr = IAMCrossbar_get_PinCounts(cross_bar, &count_output_pins, &count_input_pins);
  71.     if (hr != S_OK) {
  72.         av_log(avctx, AV_LOG_ERROR, "Unable to get crossbar pin counts\n");
  73.         return hr;
  74.     }
  75.  
  76.     for (i = 0; i < count_output_pins; i++)
  77.     {
  78.         int j;
  79.         long related_pin, pin_type, route_to_pin;
  80.         hr = IAMCrossbar_get_CrossbarPinInfo(cross_bar, FALSE, i, &related_pin, &pin_type);
  81.         if (pin_type == PhysConn_Video_VideoDecoder) {
  82.             /* assume there is only one "Video (and one Audio) Decoder" output pin, and it's all we care about routing to...for now */
  83.             if (video_input_pin != -1) {
  84.                 av_log(avctx, log_level, "Routing video input from pin %d\n", video_input_pin);
  85.                 hr = IAMCrossbar_Route(cross_bar, i, video_input_pin);
  86.                 if (hr != S_OK) {
  87.                     av_log(avctx, AV_LOG_ERROR, "Unable to route video input from pin %d\n", video_input_pin);
  88.                     return AVERROR(EIO);
  89.                 }
  90.             }
  91.         } else if (pin_type == PhysConn_Audio_AudioDecoder) {
  92.             if (audio_input_pin != -1) {
  93.                 av_log(avctx, log_level, "Routing audio input from pin %d\n", audio_input_pin);
  94.                 hr = IAMCrossbar_Route(cross_bar, i, audio_input_pin);
  95.                 if (hr != S_OK) {
  96.                     av_log(avctx, AV_LOG_ERROR, "Unable to route audio input from pin %d\n", audio_input_pin);
  97.                     return hr;
  98.                 }
  99.             }
  100.         } else {
  101.             av_log(avctx, AV_LOG_WARNING, "Unexpected output pin type, please report the type if you want to use this (%s)", GetPhysicalPinName(pin_type));
  102.         }
  103.  
  104.         hr = IAMCrossbar_get_IsRoutedTo(cross_bar, i, &route_to_pin);
  105.         if (hr != S_OK) {
  106.             av_log(avctx, AV_LOG_ERROR, "Unable to get crossbar is routed to from pin %d\n", i);
  107.             return hr;
  108.         }
  109.         av_log(avctx, log_level, "  Crossbar Output pin %d: \"%s\" related output pin: %ld ", i, GetPhysicalPinName(pin_type), related_pin);
  110.         av_log(avctx, log_level, "current input pin: %ld ", route_to_pin);
  111.         av_log(avctx, log_level, "compatible input pins: ");
  112.  
  113.         for (j = 0; j < count_input_pins; j++)
  114.         {
  115.             hr = IAMCrossbar_CanRoute(cross_bar, i, j);
  116.             if (hr == S_OK)
  117.                 av_log(avctx, log_level ,"%d ", j);
  118.         }
  119.         av_log(avctx, log_level, "\n");
  120.     }
  121.  
  122.     for (i = 0; i < count_input_pins; i++)
  123.     {
  124.         long related_pin, pin_type;
  125.         hr = IAMCrossbar_get_CrossbarPinInfo(cross_bar, TRUE, i, &related_pin, &pin_type);
  126.         if (hr != S_OK) {
  127.             av_log(avctx, AV_LOG_ERROR, "unable to get crossbar info audio input from pin %d\n", i);
  128.             return hr;
  129.         }
  130.         av_log(avctx, log_level, "  Crossbar Input pin %d - \"%s\" ", i, GetPhysicalPinName(pin_type));
  131.         av_log(avctx, log_level, "related input pin: %ld\n", related_pin);
  132.     }
  133.     return S_OK;
  134. }
  135.  
  136. /**
  137.  * Given a fully constructed graph, check if there is a cross bar filter, and configure its pins if so.
  138.  */
  139. HRESULT
  140. dshow_try_setup_crossbar_options(ICaptureGraphBuilder2 *graph_builder2,
  141.     IBaseFilter *device_filter, enum dshowDeviceType devtype, AVFormatContext *avctx)
  142. {
  143.     struct dshow_ctx *ctx = avctx->priv_data;
  144.     IAMCrossbar *cross_bar = NULL;
  145.     IBaseFilter *cross_bar_base_filter = NULL;
  146.     IAMTVTuner *tv_tuner_filter = NULL;
  147.     IBaseFilter *tv_tuner_base_filter = NULL;
  148.     IAMAudioInputMixer *tv_audio_filter = NULL;
  149.     IBaseFilter *tv_audio_base_filter = NULL;
  150.     HRESULT hr;
  151.  
  152.     hr = ICaptureGraphBuilder2_FindInterface(graph_builder2, &LOOK_UPSTREAM_ONLY, (const GUID *) NULL,
  153.             device_filter, &IID_IAMCrossbar, (void**) &cross_bar);
  154.     if (hr != S_OK) {
  155.         /* no crossbar found */
  156.         hr = S_OK;
  157.         goto end;
  158.     }
  159.     /* TODO some TV tuners apparently have multiple crossbars? */
  160.  
  161.     if (devtype == VideoDevice && ctx->show_video_crossbar_connection_dialog ||
  162.         devtype == AudioDevice && ctx->show_audio_crossbar_connection_dialog) {
  163.         hr = IAMCrossbar_QueryInterface(cross_bar, &IID_IBaseFilter, (void **) &cross_bar_base_filter);
  164.         if (hr != S_OK)
  165.             goto end;
  166.         dshow_show_filter_properties(cross_bar_base_filter, avctx);
  167.     }
  168.  
  169.     if (devtype == VideoDevice && ctx->show_analog_tv_tuner_dialog) {
  170.         hr = ICaptureGraphBuilder2_FindInterface(graph_builder2, &LOOK_UPSTREAM_ONLY, NULL,
  171.              device_filter, &IID_IAMTVTuner, (void**) &tv_tuner_filter);
  172.         if (hr == S_OK) {
  173.             hr = IAMCrossbar_QueryInterface(tv_tuner_filter, &IID_IBaseFilter, (void **) &tv_tuner_base_filter);
  174.             if (hr != S_OK)
  175.                 goto end;
  176.             dshow_show_filter_properties(tv_tuner_base_filter, avctx);
  177.         } else {
  178.             av_log(avctx, AV_LOG_WARNING, "unable to find a tv tuner to display dialog for!");
  179.         }
  180.     }
  181.     if (devtype == AudioDevice && ctx->show_analog_tv_tuner_audio_dialog) {
  182.         hr = ICaptureGraphBuilder2_FindInterface(graph_builder2, &LOOK_UPSTREAM_ONLY, NULL,
  183.              device_filter, &IID_IAMTVAudio, (void**) &tv_audio_filter);
  184.         if (hr == S_OK) {
  185.             hr = IAMCrossbar_QueryInterface(tv_audio_filter, &IID_IBaseFilter, (void **) &tv_audio_base_filter);
  186.             if (hr != S_OK)
  187.                 goto end;
  188.             dshow_show_filter_properties(tv_audio_base_filter, avctx);
  189.         } else {
  190.             av_log(avctx, AV_LOG_WARNING, "unable to find a tv audio tuner to display dialog for!");
  191.         }
  192.     }
  193.  
  194.     hr = setup_crossbar_options(cross_bar, devtype, avctx);
  195.     if (hr != S_OK)
  196.         goto end;
  197.  
  198. end:
  199.     if (cross_bar)
  200.         IAMCrossbar_Release(cross_bar);
  201.     if (cross_bar_base_filter)
  202.         IBaseFilter_Release(cross_bar_base_filter);
  203.     if (tv_tuner_filter)
  204.         IAMTVTuner_Release(tv_tuner_filter);
  205.     if (tv_tuner_base_filter)
  206.         IBaseFilter_Release(tv_tuner_base_filter);
  207.     return hr;
  208. }
  209.