示例#1
0
 private void tuneAllChannelInMosaicToolStripMenuItem_Click(object sender, EventArgs e)
 {
     if (this.treeViewChannel.SelectedNode != null && this.treeViewChannel.SelectedNode.Tag is ChannelDVB)
     {
         ChannelDVB channel = this.treeViewChannel.SelectedNode.Tag as ChannelDVB;
         MainForm.TuneChannelGUI((Channel)channel);
     }
 }
        private void buttonChannelUpdatePid_Click(object sender, EventArgs e)
        {
            if (this.propertyGridChannel.SelectedObject is ChannelDVB)
            {
                ChannelDVB           currentChannelTV = this.propertyGridChannel.SelectedObject as ChannelDVB;
                ChannelDVB.VideoType videoType        = currentChannelTV.VideoDecoderType;
                if (videoType != ChannelDVB.VideoType.MPEG2)
                {
                    currentChannelTV.VideoDecoderType = ChannelDVB.VideoType.MPEG2;
                }
                MainForm.TuneChannelGUI(currentChannelTV);
                if (MainForm.GraphBuilder is GraphBuilderBDA)
                {
                    IMpeg2Data mpeg2Data = (MainForm.GraphBuilder as GraphBuilderBDA).SectionsAndTables as IMpeg2Data;
                    if (mpeg2Data == null)
                    {
                        MessageBox.Show(Properties.Resources.CannotUpdatePidChannel);
                        return;
                    }

                    PSISection[] psis = PSISection.GetPSITable((int)PIDS.PAT, (int)TABLE_IDS.PAT, mpeg2Data);
                    for (int i = 0; i < psis.Length; i++)
                    {
                        PSISection psi = psis[i];
                        if (psi != null && psi is PSIPAT)
                        {
                            PSIPAT pat = (PSIPAT)psi;
                            Trace.WriteLineIf(MainForm.trace.TraceVerbose, "PSI Table " + i + "/" + psis.Length + "\r\n");
                            Trace.WriteLineIf(MainForm.trace.TraceVerbose, pat.ToString());

                            foreach (PSIPAT.Data program in pat.ProgramIds)
                            {
                                if (program.ProgramNumber == currentChannelTV.SID)
                                {
                                    WizardForm.UpdateDVBChannelPids(mpeg2Data, program.Pid, currentChannelTV);
                                    this.propertyGridChannel.SelectedObject = currentChannelTV;
                                    if (videoType != ChannelDVB.VideoType.MPEG2)
                                    {
                                        currentChannelTV.VideoDecoderType = videoType;
                                    }
                                    MainForm.TuneChannelGUI(currentChannelTV);
                                    return;
                                }
                            }
                        }
                    }
                }
            }
        }
示例#3
0
        internal static void UpdateDVBChannelPids(IMpeg2Data mpeg2Data, ushort pmtPid, ChannelDVB channelDVB)
        {
            Hashtable hashtableEcmPids = new Hashtable();

            channelDVB.PmtPid = pmtPid;

            PSISection[] psiPmts = PSISection.GetPSITable(pmtPid, (int)TABLE_IDS.PMT, mpeg2Data);
            for (int i2 = 0; i2 < psiPmts.Length; i2++)
            {
                PSISection psiPmt = psiPmts[i2];
                if (psiPmt != null && psiPmt is PSIPMT)
                {
                    PSIPMT pmt = (PSIPMT)psiPmt;

                    channelDVB.PcrPid = pmt.PcrPid;
                    if (pmt.Descriptors != null)
                    {
                        foreach (PSIDescriptor descriptor in pmt.Descriptors)
                        {
                            switch (descriptor.DescriptorTag)
                            {
                            case DESCRIPTOR_TAGS.DESCR_CA:
                                hashtableEcmPids[(descriptor as PSIDescriptorCA).CaPid] = (descriptor as PSIDescriptorCA).CaSystemId;
                                break;
                            }
                        }
                    }

                    channelDVB.VideoPid  = -1;
                    channelDVB.AudioPid  = -1;
                    channelDVB.AudioPids = new int[0];
                    channelDVB.EcmPids   = new int[0];

                    foreach (PSIPMT.Data data in pmt.Streams)
                    {
                        switch ((int)data.StreamType)
                        {
                        case (int)STREAM_TYPES.STREAMTYPE_11172_VIDEO:
                        case (int)STREAM_TYPES.STREAMTYPE_13818_VIDEO:
                            //channelDVB.VideoDecoderType = ChannelDVB.VideoType.MPEG2;
                            channelDVB.VideoPid = data.Pid;
                            if (data.Descriptors != null)
                            {
                                foreach (PSIDescriptor descriptor in data.Descriptors)
                                {
                                    if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_CA)
                                    {
                                        hashtableEcmPids[(descriptor as PSIDescriptorCA).CaPid] = (descriptor as PSIDescriptorCA).CaSystemId;
                                    }
                                }
                            }
                            break;

                        case 27:                                 //H264
                            channelDVB.VideoDecoderType = ChannelDVB.VideoType.H264;
                            channelDVB.VideoPid         = data.Pid;
                            if (data.Descriptors != null)
                            {
                                foreach (PSIDescriptor descriptor in data.Descriptors)
                                {
                                    if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_CA)
                                    {
                                        hashtableEcmPids[(descriptor as PSIDescriptorCA).CaPid] = (descriptor as PSIDescriptorCA).CaSystemId;
                                    }
                                }
                            }
                            break;

                        case (int)STREAM_TYPES.STREAMTYPE_11172_AUDIO:
                        case (int)STREAM_TYPES.STREAMTYPE_13818_AUDIO:
                        {
                            int[] audioPids = new int[channelDVB.AudioPids.Length + 1];
                            Array.Copy(channelDVB.AudioPids, audioPids, channelDVB.AudioPids.Length);
                            audioPids[channelDVB.AudioPids.Length] = data.Pid;
                            channelDVB.AudioPids = audioPids;
                            if (audioPids.Length == 1)         // If it is the first one
                            {
                                channelDVB.AudioPid         = data.Pid;
                                channelDVB.AudioDecoderType = ChannelDVB.AudioType.MPEG2;
                            }

                            foreach (PSIDescriptor descriptor in data.Descriptors)
                            {
                                if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_CA)
                                {
                                    hashtableEcmPids[(descriptor as PSIDescriptorCA).CaPid] = (descriptor as PSIDescriptorCA).CaSystemId;
                                }
                            }
                        }
                        break;

                        case (int)STREAM_TYPES.STREAMTYPE_13818_PES_PRIVATE:
                            if (data.Descriptors != null)
                            {
                                foreach (PSIDescriptor descriptor in data.Descriptors)
                                {
                                    if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_TELETEXT)
                                    {
                                        channelDVB.TeletextPid = data.Pid;
                                    }
                                    else if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_AC3 || descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_ENHANCED_AC3)
                                    {
                                        //Audio again
                                        int[] audioPids = new int[channelDVB.AudioPids.Length + 1];
                                        Array.Copy(channelDVB.AudioPids, audioPids, channelDVB.AudioPids.Length);
                                        audioPids[channelDVB.AudioPids.Length] = data.Pid;
                                        channelDVB.AudioPids = audioPids;
                                        if (audioPids.Length == 1)     // If it is the first one
                                        {
                                            channelDVB.AudioPid = data.Pid;
                                            if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_AC3)
                                            {
                                                channelDVB.AudioDecoderType = ChannelDVB.AudioType.AC3;
                                            }
                                            if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_ENHANCED_AC3)
                                            {
                                                channelDVB.AudioDecoderType = ChannelDVB.AudioType.EAC3;
                                            }
                                        }
                                    }
                                    else if (descriptor.DescriptorTag == DESCRIPTOR_TAGS.DESCR_ISO_639_LANGUAGE)
                                    {
                                    }
                                }
                            }
                            break;
                        }
                    }
                }
            }

            channelDVB.EcmPids = new int[hashtableEcmPids.Count];
            hashtableEcmPids.Keys.CopyTo(channelDVB.EcmPids, 0);
            if (channelDVB.EcmPids.Length > 0)
            {
                channelDVB.EcmPid = channelDVB.EcmPids[0];
            }
        }
示例#4
0
        private bool ScanProbeFrequency(ChannelTV currentChannelTV, bool needRebuild)
        {
            this.propertyGridChannel.SelectedObject = currentChannelTV;
            Application.DoEvents();

            MainForm.videoControl.BackColor = Color.Transparent;
            try
            {
                MainForm.TuneChannel(currentChannelTV, needRebuild);
                needRebuild            = false;
                textBoxScanStatus.Text = Properties.Resources.Scanning;
                if (currentChannelTV is ChannelDVB)
                {
                    textBoxScanFrequency.Text = string.Format(Properties.Resources.ScanningFrequency, (currentChannelTV as ChannelDVB).Frequency);
                }
                else if (currentChannelTV is ChannelAnalogic)
                {
                    textBoxScanFrequency.Text = string.Format(Properties.Resources.ScanningChannel, (currentChannelTV as ChannelAnalogic).Channel);
                }
            }
            catch (Exception ex)
            {
                Trace.WriteLineIf(MainForm.trace.TraceError, ex.ToString());
                textBoxScanStatus.Text          = Properties.Resources.Error + " " + ex.Message;
                textBoxScanFrequency.Text       = Properties.Resources.ScanningError;
                MainForm.videoControl.BackColor = MainForm.Settings.VideoBackgroundColor;
            }

            if (currentChannelTV is ChannelDVB)
            {
                if (MainForm.GraphBuilder is IBDA)
                {
                    IBDA graphBuilderBDA = MainForm.GraphBuilder as IBDA;
                    bool locked, present;
                    int  strength, quality;
                    System.Threading.Thread.Sleep(500);
                    if ((graphBuilderBDA as ITV).GetSignalStatistics(out locked, out present, out strength, out quality))
                    {
                        if (locked && present)
                        {
                            IMpeg2Data mpeg2Data = graphBuilderBDA.SectionsAndTables as IMpeg2Data;

                            short     originalNetworkId      = -1;
                            Hashtable serviceNameByServiceId = new Hashtable();
                            // Hervé Stalin : Ajout d'une hashtable pour le services_type d'un service
                            Hashtable    serviceTypeByServiceID = new Hashtable();
                            PSISection[] psiSdts = PSISection.GetPSITable((int)PIDS.SDT, (int)TABLE_IDS.SDT_ACTUAL, mpeg2Data);
                            for (int i = 0; i < psiSdts.Length; i++)
                            {
                                PSISection psiSdt = psiSdts[i];
                                if (psiSdt != null && psiSdt is PSISDT)
                                {
                                    PSISDT sdt = (PSISDT)psiSdt;
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, "PSI Table " + i + "/" + psiSdts.Length + "\r\n");
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, sdt.ToString());

                                    originalNetworkId = (short)sdt.OriginalNetworkId;
                                    foreach (PSISDT.Data service in sdt.Services)
                                    {
                                        serviceNameByServiceId[service.ServiceId] = service.GetServiceName();
                                        //Hervé Stalin : remplissage du hashtable du service_type
                                        serviceTypeByServiceID[service.ServiceId] = service.GetServiceType();
                                    }
                                }
                            }

                            //Hervé Stalin : Code pode pour créér un hashtable de lcn
                            Hashtable    logicalChannelNumberByServiceId = new Hashtable();
                            PSISection[] psiNits = PSISection.GetPSITable((int)PIDS.NIT, (int)TABLE_IDS.NIT_ACTUAL, mpeg2Data);
                            for (int i = 0; i < psiNits.Length; i++)
                            {
                                PSISection psinit = psiNits[i];
                                if (psinit != null && psinit is PSINIT)
                                {
                                    PSINIT nit = (PSINIT)psinit;
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, "PSI Table " + i + "/" + psiNits.Length + "\r\n");
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, nit.ToString());

                                    foreach (PSINIT.Data data in nit.Streams)
                                    {
                                        foreach (PSIDescriptor psiDescriptorData in data.Descriptors)
                                        {
                                            if (psiDescriptorData.DescriptorTag == DESCRIPTOR_TAGS.DESCR_LOGICAL_CHANNEL)
                                            {
                                                PSIDescriptorLogicalChannel psiDescriptorLogicalChannel = (PSIDescriptorLogicalChannel)psiDescriptorData;
                                                foreach (PSIDescriptorLogicalChannel.ChannelNumber f in psiDescriptorLogicalChannel.LogicalChannelNumbers)
                                                {
                                                    logicalChannelNumberByServiceId[f.ServiceID] = f.LogicalChannelNumber;
                                                }
                                            }
                                        }
                                    }
                                }
                            }

                            PSISection[] psis = PSISection.GetPSITable((int)PIDS.PAT, (int)TABLE_IDS.PAT, mpeg2Data);
                            for (int i = 0; i < psis.Length; i++)
                            {
                                PSISection psi = psis[i];
                                if (psi != null && psi is PSIPAT)
                                {
                                    PSIPAT pat = (PSIPAT)psi;
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, "PSI Table " + i + "/" + psis.Length + "\r\n");
                                    Trace.WriteLineIf(MainForm.trace.TraceVerbose, pat.ToString());

                                    ChannelDVB newTemplateChannelDVB = (MainForm.GraphBuilder as ITV).CurrentChannel.MakeCopy() as ChannelDVB;
                                    newTemplateChannelDVB.ONID = originalNetworkId;
                                    newTemplateChannelDVB.TSID = pat.TransportStreamId;

                                    foreach (PSIPAT.Data program in pat.ProgramIds)
                                    {
                                        if (!program.IsNetworkPID)                                         // Hervé Stalin : est encore utile ?
                                        {
                                            //Hervé Stalin: discrimination par le service type
                                            SERVICE_TYPES st;
                                            try
                                            {
                                                st = (SERVICE_TYPES)serviceTypeByServiceID[program.ProgramNumber];
                                            }
                                            catch
                                            {
                                                st = SERVICE_TYPES.DIGITAL_TELEVISION_SERVICE;                                                  // bypass en cas de probleme de parsing (mauvaise réception dans mon cas)
                                            }

                                            if (st == SERVICE_TYPES.DIGITAL_TELEVISION_SERVICE ||                                                                   // TV SD MPEG2
                                                st == SERVICE_TYPES.ADVANCE_CODEC_HD_DIGITAL_SERVICE ||                                                             // TV HD H264
                                                st == SERVICE_TYPES.ADVANCE_CODEC_SD_DIGITAL_SERVICE ||                                                             // TV SD H264
                                                st == SERVICE_TYPES.MPEG2_HD_DIGITAL_TELEVISION_SERVICE ||                                                          // TV HD MPEG2
                                                st == SERVICE_TYPES.DIGITAL_RADIO_SOUND_SERVICE ||                                                                  // Radio MP2
                                                st == SERVICE_TYPES.ADVANCED_CODEC_DIGITAL_RADIO_SOUND_SERVICE ||                                                   // Radio AC3/E-AC3/AAC
                                                st == SERVICE_TYPES.MOSAIC_SERVICE ||                                                                               // Mosaic MPEG2
                                                st == SERVICE_TYPES.ADVANCED_CODEC_MOSAIC_SERVICE)                                                                  // Mosaic H264

                                            {
                                                ChannelDVB newChannelDVB = newTemplateChannelDVB.MakeCopy() as ChannelDVB;
                                                newChannelDVB.SID  = program.ProgramNumber;
                                                newChannelDVB.Name = (string)serviceNameByServiceId[program.ProgramNumber];
                                                //Hervé Stalin: ajout du LCN
                                                newChannelDVB.ChannelNumber = Convert.ToInt16(logicalChannelNumberByServiceId[program.ProgramNumber]);

                                                if (newChannelDVB.Name == null)
                                                {
                                                    newChannelDVB.Name = Properties.Resources.NoName;
                                                }

                                                UpdateDVBChannelPids(mpeg2Data, program.Pid, newChannelDVB);

                                                ListViewItem lvi = new ListViewItem(newChannelDVB.Name, "LogoTVDefault");
                                                lvi.SubItems.Add(newChannelDVB.Frequency.ToString());
                                                lvi.SubItems.Add(newChannelDVB.ChannelNumber.ToString());
                                                lvi.Tag = newChannelDVB;
                                                //this.listViewScanResult.SmallImageList = MainForm.imageListLogoTV;
                                                this.listViewScanResult.Items.Add(lvi);
                                                this.buttonScanClear.Enabled = true;

                                                try
                                                {
                                                    var extensions = new HashSet <string>(StringComparer.OrdinalIgnoreCase)
                                                    {
                                                        ".gif", ".png", ".jpg", ".jpeg", ".bmp"
                                                    };
                                                    //var files = Directory.EnumerateFiles(@".\Logos\", "*");
                                                    var files = Directory.GetFiles(@".\Logos\", "*");
                                                    foreach (var logo in files)
                                                    {
                                                        string extension = Path.GetExtension(logo).ToLowerInvariant();
                                                        if (extensions.Contains(extension))
                                                        {
                                                            string filename = Path.GetFileNameWithoutExtension(logo).ToLowerInvariant();
                                                            if (newChannelDVB.Name.ToLowerInvariant().IndexOf(filename) != -1)
                                                            {
                                                                newChannelDVB.Logo = logo;
                                                                //MainForm.panelChannel.AdjustTVLogo(newChannelDVB);
                                                                if (MainForm.imageListLogoTV.Images.ContainsKey(logo))
                                                                {
                                                                    lvi.ImageKey = logo;
                                                                }
                                                                else
                                                                {
                                                                    try
                                                                    {
                                                                        string path = FileUtils.GetAbsolutePath(logo);
                                                                        if (File.Exists(path))
                                                                        {
                                                                            Bitmap bitmap = new Bitmap(path);
                                                                            //if (!Bitmap.IsAlphaPixelFormat(bitmap.PixelFormat))
                                                                            //    bitmap.MakeTransparent(Color.White);
                                                                            Image thumbnail = Utils.ResizeImage(bitmap, 16, 16, false);
                                                                            MainForm.imageListLogoTV.Images.Add(logo, thumbnail);
                                                                            lvi.ImageKey = logo;
                                                                            thumbnail.Dispose();
                                                                            bitmap.Dispose();
                                                                            break;
                                                                        }
                                                                    }
                                                                    catch (ArgumentException) { }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                                catch (Exception)
                                                {
                                                }

                                                //PSISection[] psis2 = PSISection.GetPSITable(program.Pid, (int)TABLE_IDS.PMT, mpeg2Data);
                                                //for (int i2 = 0; i2 < psis2.Length; i2++)
                                                //{
                                                //    PSISection psi2 = psis2[i2];
                                                //    if (psi2 != null && psi2 is PSIPMT)
                                                //    {
                                                //        PSIPMT pmt = (PSIPMT)psi2;
                                                //        Trace.WriteLineIf(trace.TraceVerbose, "PSI Table " + i2 + "/" + psis2.Length + "\r\n");
                                                //        Trace.WriteLineIf(trace.TraceVerbose, pmt.ToString());
                                                //    }
                                                //}
                                            }
                                        }
                                    }

                                    Application.DoEvents();
                                }
                            }
                        }
                    }
                }
            }
            else if (currentChannelTV is ChannelAnalogic)
            {
                GraphBuilderWDM graphBuilderWDM = MainForm.GraphBuilder as GraphBuilderWDM;
                if (graphBuilderWDM.CurrentChannel != null)
                {
                    bool locked, present;
                    int  strength, quality;
                    if (graphBuilderWDM.GetSignalStatistics(out locked, out present, out strength, out quality))
                    {
                        if (locked && present)
                        {
                            ChannelAnalogic newChannel = graphBuilderWDM.CurrentChannel.MakeCopy() as ChannelAnalogic;
                            newChannel.Name = Properties.Resources.NewChannelName + " " + newChannel.Channel.ToString();

                            ListViewItem lvi = new ListViewItem(newChannel.Name, "LogoTVDefault");
                            lvi.SubItems.Add(newChannel.Channel.ToString());
                            lvi.Tag = newChannel;
                            this.listViewScanResult.Items.Add(lvi);
                            this.buttonScanClear.Enabled = true;
                        }
                    }
                }
            }
            return(needRebuild);
        }