예제 #1
0
        static bool encode(Options opt)
        {
            DeleteFile(opt.OutputFile);

            MediaSocket inSocket  = CreateInputSocket(opt);
            MediaSocket outSocket = CreateOutputSocket(opt);

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                bool res = transcoder.Open();
                PrintStatus("Transcoder open", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                res = transcoder.Run();
                PrintStatus("Transcoder run", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                transcoder.Close();
                PrintStatus("Transcoder close", transcoder.Error);
            }

            return(true);
        }
예제 #2
0
        // return error message or null if success
        public static string ConvertFileWithPreset(string inputFile, string outputFile, string outputPreset,
                                                   EventHandler <TranscoderContinueEventArgs> onContinue,
                                                   EventHandler <TranscoderProgressEventArgs> onProgress,
                                                   EventHandler <TranscoderStatusEventArgs> onStatus
                                                   )
        {
            using (MediaInfo mediaInfo = new MediaInfo())
            {
                mediaInfo.Inputs[0].File = inputFile;
                if (!mediaInfo.Open())
                {
                    return(FormatErrorMessage(mediaInfo.Error));
                }

                using (Transcoder t = new Transcoder())
                {
                    // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
                    t.AllowDemoMode = true;

                    if (onContinue != null)
                    {
                        t.OnContinue += onContinue;
                    }

                    if (onProgress != null)
                    {
                        t.OnProgress += onProgress;
                    }

                    if (onStatus != null)
                    {
                        t.OnStatus += onStatus;
                    }

                    MediaSocket insocket = MediaSocket.FromMediaInfo(mediaInfo);
                    t.Inputs.Add(insocket);
                    MediaSocket outsocket = MediaSocket.FromPreset(outputPreset);
                    if (outsocket == null)
                    {
                        return("Cannot create output preset");
                    }
                    outsocket.File = outputFile;
                    t.Outputs.Add(outsocket);

                    if (!t.Open())
                    {
                        return(FormatErrorMessage(t.Error));
                    }

                    if (!t.Run())
                    {
                        return(FormatErrorMessage(t.Error));
                    }

                    t.Close();
                }
            }

            return(null); // no error
        }
예제 #3
0
        static bool Encode(Options opt)
        {
            DeleteFile(opt.OutputFile);

            MediaSocket inSocket = new MediaSocket();

            inSocket.File = opt.InputFile;

            MediaSocket outSocket = CreateOutputSocket(opt);

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                if (!transcoder.Open())
                {
                    PrintError("Transcoder open", transcoder.Error);
                    return(false);
                }

                if (!transcoder.Run())
                {
                    PrintError("Transcoder run", transcoder.Error);
                    return(false);
                }

                transcoder.Close();
            }

            return(true);
        }
예제 #4
0
        static bool EncodeImageToMpeg2Video(string imageFile, string outputFile, string encodingPreset)
        {
            Transcoder transcoder = new Transcoder();

            // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
            transcoder.AllowDemoMode = true;

            try
            {
                File.Delete(outputFile);

                // Configure Input
                {
                    MediaInfo info = new MediaInfo();
                    info.InputFile = imageFile;
                    if (!info.Load())
                    {
                        PrintError("MediaInfo load", info.Error);
                        return(false);
                    }

                    MediaSocket socket = MediaSocket.FromMediaInfo(info);
                    transcoder.Inputs.Add(socket);
                }

                // Configure Output
                {
                    MediaSocket socket = MediaSocket.FromPreset(encodingPreset);
                    socket.File = outputFile;
                    transcoder.Outputs.Add(socket);
                }

                // Encode Images
                if (!transcoder.Open())
                {
                    PrintError("Transcoder open", transcoder.Error);
                    return(false);
                }

                if (!transcoder.Run())
                {
                    PrintError("Transcoder run", transcoder.Error);
                    return(false);
                }

                transcoder.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return(false);
            }
            finally
            {
                transcoder.Dispose();
            }

            return(true);
        }
예제 #5
0
        static bool Encode(Options opt)
        {
            try { File.Delete(opt.OutputFile); }
            catch { }

            using (var transcoder = new Transcoder())
            {
                // Transcoder demo mode must be enabled, 
                // in order to use the OEM release for testing (without a valid license).
                transcoder.AllowDemoMode = true;

                // Configure input
                // The input stream frame rate determines the playback speed
                var instream = new VideoStreamInfo {
                    StreamType = PrimoSoftware.AVBlocks.StreamType.UncompressedVideo,
                    FrameRate = opt.YuvFps, 
                    FrameWidth = opt.YuvWidth,
                    FrameHeight = opt.YuvHeight,
                    ColorFormat = opt.YuvColor.Id,
                    ScanType = ScanType.Progressive
                };

                var inpin = new MediaPin {
                    StreamInfo = instream
                };

                var insocket = new MediaSocket {
                    StreamType = PrimoSoftware.AVBlocks.StreamType.UncompressedVideo,
                    File = opt.YuvFile
                };

                insocket.Pins.Add(inpin);

                transcoder.Inputs.Add(insocket);

                // Configure output
                var outsocket = MediaSocket.FromPreset(opt.OutputPreset.Name);

                outsocket.File = opt.OutputFile;

                transcoder.Outputs.Add(outsocket);

                bool res = transcoder.Open();
                PrintError("Open Transcoder", transcoder.Error);
                if (!res)
                    return false;

                res = transcoder.Run();
                PrintError("Run Transcoder", transcoder.Error);
                if (!res)
                    return false;

                transcoder.Close();
            }

            return true;
        }
예제 #6
0
        static bool Transcode(Options opt)
        {
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;

                MediaSocket inSocket  = CreateInputSocket(opt);
                MediaSocket outSocket = CreateOutputSocket(opt);

                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                DeleteFile(opt.OutputFile);

                if (!transcoder.Open())
                {
                    PrintStatus("Transcoder open", transcoder.Error);
                    return(false);
                }

                for (int fileCount = 0; ; fileCount++)
                {
                    string pattern  = "au_{0:0000}.h264";
                    string fileName = string.Format(pattern, fileCount);
                    string filePath = Path.Combine(opt.InputDir, fileName);

                    if (!File.Exists(filePath))
                    {
                        fileName = string.Format(pattern, fileCount - 1);
                        Console.WriteLine("Decoded " + fileCount + " files." + "(last decoded file: " + fileName + ")");
                        break;
                    }

                    var sample = new MediaSample();
                    sample.Buffer = new MediaBuffer(File.ReadAllBytes(filePath));

                    if (!transcoder.Push(0, sample))
                    {
                        PrintStatus("Transcoder push", transcoder.Error);
                        return(false);
                    }
                }

                if (!transcoder.Flush())
                {
                    PrintStatus("Transcoder flush", transcoder.Error);
                    return(false);
                }

                Console.WriteLine("Output file: " + opt.OutputFile);

                transcoder.Close();

                return(true);
            }
        }
예제 #7
0
        static bool Encode(Options opt)
        {
            DeleteFile(opt.OutputFile);

            MediaSocket inSocket = new MediaSocket();

            inSocket.File = opt.InputFile;

            MediaSocket outSocket = CreateOutputSocket(opt);

            bool success = false;

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                if (!transcoder.Open())
                {
                    PrintError("Transcoder open", transcoder.Error);
                    return(false);
                }

                using (FileStream outputFile = File.OpenWrite(opt.OutputFile))
                {
                    MediaSample outputSample = new MediaSample();
                    int         outputIndex  = -1;

                    while (transcoder.Pull(out outputIndex, outputSample))
                    {
                        MediaBuffer buffer = outputSample.Buffer;
                        outputFile.Write(buffer.Start, buffer.DataOffset, buffer.DataSize);
                    }

                    ErrorInfo error = transcoder.Error;
                    PrintError("Transcoder pull", error);

                    if ((error.Code == (int)CodecError.EOS) &&
                        (error.Facility == ErrorFacility.Codec))
                    {
                        // ok
                        success = true;
                    }
                }

                transcoder.Close();
            }

            return(success);
        }
예제 #8
0
        static bool DecodeAvcFile(Options opt)
        {
            // transcoder will fail if output exists (by design)
            DeleteFile(opt.OutputFile);

            var mediaInfo = new PrimoSoftware.AVBlocks.MediaInfo();

            mediaInfo.Inputs[0].File = opt.InputFile;

            if (!mediaInfo.Open())
            {
                PrintError("MediaInfo.Open()", mediaInfo.Error);
                return(false);
            }

            MediaSocket inSocket  = MediaSocket.FromMediaInfo(mediaInfo);
            MediaSocket outSocket = CreateOutputSocket(opt);

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                bool res = transcoder.Open();
                PrintError("Transcoder open", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                res = transcoder.Run();
                PrintError("Transcoder run", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                transcoder.Close();
                PrintError("Transcoder close", transcoder.Error);
                if (!res)
                {
                    return(false);
                }
            }

            return(true);
        }
예제 #9
0
        static int Main(string[] args)
        {
            var opt = new Options();

            if (!opt.Prepare(args))
            {
                return((int)ExitCodes.OptionsError);
            }

            Library.Initialize();

            MediaSocket inSocket  = CreateInputSocket(opt);
            MediaSocket outSocket = CreateOutputSocket(opt);

            int exitCode = (int)ExitCodes.Success;

            // Set license information. To run AVBlocks in demo mode, comment the next line out
            // Library.SetLicense("<license-string>");
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                DeleteFile(opt.OutputFile);

                if (transcoder.Open())
                {
                    PrintStatus("Transcoder open", transcoder.Error);
                    if (!EncodeH264Stream(opt, transcoder))
                    {
                        exitCode = (int)ExitCodes.EncodingError;
                    }

                    transcoder.Close();
                    PrintStatus("Transcoder close", transcoder.Error);
                }
                else
                {
                    PrintStatus("Transcoder open", transcoder.Error);
                    exitCode = (int)ExitCodes.EncodingError;
                }
            }

            Library.Shutdown();

            return(exitCode);
        }
예제 #10
0
        static bool transcodeAUs(Options opt)
        {
            using (var transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;

                string imgFile = BuildImgPath(opt, 0);

                if (!setTranscode(transcoder, imgFile, opt))
                {
                    return(false);
                }

                for (int i = 0; ; i++)
                {
                    if (i > 0)
                    {
                        imgFile = BuildImgPath(opt, i);
                    }

                    if (!File.Exists(imgFile))
                    {
                        break;
                    }

                    var sample = new MediaSample();
                    sample.Buffer = new MediaBuffer(File.ReadAllBytes(imgFile));

                    if (!transcoder.Push(0, sample))
                    {
                        PrintError("Transcoder push", transcoder.Error);
                        return(false);
                    }
                }

                if (!transcoder.Flush())
                {
                    PrintError("Transcoder flush", transcoder.Error);
                    return(false);
                }

                Console.WriteLine("Output file: " + opt.OutputFile);

                transcoder.Close();
            }

            return(true);
        }
예제 #11
0
        static bool ApplyOverlay(Options opt)
        {
            DeleteFile(opt.OutputFile);

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;

                MediaSocket inputSocket = new MediaSocket();
                inputSocket.File = opt.InputFile;
                transcoder.Inputs.Add(inputSocket);

                MediaSocket outputSocket = ConfigureOutputSocket(opt);
                transcoder.Outputs.Add(outputSocket);

                bool res = transcoder.Open();

                if (!res)
                {
                    PrintError("Transcoder open", transcoder.Error);
                    return(false);
                }

                res = transcoder.Run();

                if (!res)
                {
                    PrintError("Transcoder run", transcoder.Error);
                    return(false);
                }

                transcoder.Close();
            }

            Console.WriteLine("Output: " + opt.OutputFile);

            return(true);
        }
예제 #12
0
        static bool EncodeImagesToMpeg2Video(string imagesFolder, string outputFile, int imagesCount, int videoFramesPerImage, int step, string encodingPreset)
        {
            double frameRate = -1;

            switch (encodingPreset)
            {
            case Preset.Video.DVD.PAL_4x3_MP2:
            case Preset.Video.DVD.PAL_16x9_MP2:
                frameRate = 25.0;
                break;

            case Preset.Video.DVD.NTSC_4x3_MP2:
            case Preset.Video.DVD.NTSC_16x9_MP2:
                frameRate = 30000.0 / 1001;     // 29.97
                break;

            default:
                return(false);
            }

            Transcoder transcoder = new Transcoder();

            // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
            transcoder.AllowDemoMode = true;

            try
            {
                File.Delete(outputFile);

                // Configure Input
                {
                    MediaInfo info = new MediaInfo();
                    info.InputFile = GetImagePath(imagesFolder, 0);
                    if (!info.Load())
                    {
                        PrintError("MediaInfo load", info.Error);
                        return(false);
                    }

                    MediaPin        pin   = new MediaPin();
                    VideoStreamInfo vInfo = (VideoStreamInfo)info.Streams[0];
                    vInfo.FrameRate = frameRate;
                    pin.StreamInfo  = vInfo;

                    MediaSocket socket = new MediaSocket();
                    socket.Pins.Add(pin);

                    transcoder.Inputs.Add(socket);
                }

                // Configure Output
                {
                    MediaSocket socket = MediaSocket.FromPreset(encodingPreset);
                    socket.File = outputFile;
                    transcoder.Outputs.Add(socket);
                }

                // Encode Images
                if (!transcoder.Open())
                {
                    PrintError("Transcoder open", transcoder.Error);
                    return(false);
                }

                int totalVideoFrames = imagesCount * videoFramesPerImage;

                for (int i = 0; i < totalVideoFrames; i++)
                {
                    string      imagePath   = GetImagePath(imagesFolder, i / videoFramesPerImage * step);
                    MediaBuffer mediaBuffer = new MediaBuffer(File.ReadAllBytes(imagePath));
                    MediaSample mediaSample = new MediaSample();
                    mediaSample.Buffer = mediaBuffer;

                    mediaSample.StartTime = i / frameRate;

                    if (!transcoder.Push(0, mediaSample))
                    {
                        PrintError("Transcoder write", transcoder.Error);
                        return(false);
                    }
                }

                if (!transcoder.Flush())
                {
                    PrintError("Transcoder flush", transcoder.Error);
                    return(false);
                }

                transcoder.Close();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.ToString());
                return(false);
            }
            finally
            {
                transcoder.Dispose();
            }

            return(true);
        }
예제 #13
0
        static bool Encode(Options opt)
        {
            try { File.Delete(opt.OutputFile); }
            catch { }

            System.IO.Stream inputStream  = null;
            System.IO.Stream outputStream = null;

            try
            {
                inputStream  = new System.IO.FileStream(opt.YuvFile, FileMode.Open, FileAccess.Read, FileShare.Read);
                outputStream = new System.IO.FileStream(opt.OutputFile, FileMode.Create, FileAccess.Write, FileShare.None);

                using (var transcoder = new Transcoder())
                {
                    // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
                    transcoder.AllowDemoMode = true;

                    // Configure input
                    var instream = new VideoStreamInfo
                    {
                        FrameRate   = opt.YuvFps, // the input frame rate determines how fast the video is played
                        FrameWidth  = opt.YuvWidth,
                        FrameHeight = opt.YuvHeight,
                        ColorFormat = opt.YuvColor.Id,
                        StreamType  = PrimoSoftware.AVBlocks.StreamType.UncompressedVideo,
                        ScanType    = ScanType.Progressive
                    };

                    var inpin = new MediaPin
                    {
                        StreamInfo = instream
                    };

                    var insocket = new MediaSocket
                    {
                        Stream     = inputStream,
                        StreamType = PrimoSoftware.AVBlocks.StreamType.UncompressedVideo
                    };


                    insocket.Pins.Add(inpin);

                    transcoder.Inputs.Add(insocket);

                    // Configure output
                    var outsocket = MediaSocket.FromPreset(opt.OutputPreset.Name);
                    outsocket.Stream = outputStream;

                    transcoder.Outputs.Add(outsocket);

                    bool res = transcoder.Open();
                    PrintError("Open Transcoder", transcoder.Error);
                    if (!res)
                    {
                        return(false);
                    }

                    res = transcoder.Run();
                    PrintError("Run Transcoder", transcoder.Error);
                    if (!res)
                    {
                        return(false);
                    }

                    transcoder.Close();
                }
            }
            finally
            {
                if (inputStream != null)
                {
                    inputStream.Dispose();
                    inputStream = null;
                }

                if (outputStream != null)
                {
                    outputStream.Dispose();
                    outputStream = null;
                }
            }

            return(true);
        }
예제 #14
0
        static bool DecodeJpeg(string inputFile, string outputFile)
        {
            int frameWidth, frameHeight;

            if (!GetFrameSize(inputFile, out frameWidth, out frameHeight))
            {
                return(false);
            }

            Console.WriteLine("Input frame size: {0}x{1}", frameWidth, frameHeight);

            // read input bytes
            byte[] inputData;
            try
            {
                inputData = System.IO.File.ReadAllBytes(inputFile);
            }
            catch (System.Exception e)
            {
                Console.WriteLine(e.ToString());
                return(false);
            }

            DeleteFile(outputFile);

            MediaSocket inSocket  = createInputSocket(frameWidth, frameHeight);
            MediaSocket outSocket = createOutputSocket(outputFile, frameWidth, frameHeight);

            // create Transcoder
            using (Transcoder transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                bool res = transcoder.Open();
                PrintError("Open Transcoder", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                MediaBuffer buffer = new MediaBuffer();
                buffer.Attach(inputData, true);

                MediaSample sample = new MediaSample();
                sample.Buffer = buffer;

                res = transcoder.Push(0, sample);

                PrintError("Push Transcoder", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                transcoder.Flush();
                transcoder.Close();
            }

            return(true);
        }
예제 #15
0
        /*
         * uncompressed audio and video input
         */
        public static bool Run(MediaSocket vinput, string vfile, MediaSocket ainput, string afile, MediaSocket output)
        {
            bool res;

            TrackState vtrack = new TrackState();
            TrackState atrack = new TrackState();

            using (UncompressedAVSplitter vsplit = new UncompressedAVSplitter())
                using (UncompressedAVSplitter asplit = new UncompressedAVSplitter())
                    using (var transcoder = new Transcoder()
                    {
                        AllowDemoMode = true
                    })
                    {
                        try
                        {
                            if (vinput != null)
                            {
                                Console.WriteLine("video input file: \"{0}\"", vfile);
                                vsplit.Init(vinput, vfile);
                                Console.WriteLine("OK");
                            }

                            if (ainput != null)
                            {
                                Console.WriteLine("audio input file: \"{0}\"", afile);
                                asplit.Init(ainput, afile);
                                Console.WriteLine("OK");
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                            return(false);
                        }

                        // setup transcoder
                        int trackIndex = 0; // start index

                        if (vinput != null)
                        {
                            transcoder.Inputs.Add(vinput);
                            vtrack.Index = trackIndex++;
                        }

                        if (ainput != null)
                        {
                            transcoder.Inputs.Add(ainput);
                            atrack.Index = trackIndex++;
                        }

                        transcoder.Outputs.Add(output);

                        res = transcoder.Open();
                        PrintError("transcoder open", transcoder.Error);
                        if (!res)
                        {
                            return(false);
                        }

                        // transcoding loop
                        for (;;)
                        {
                            if (vtrack.Index != TrackState.Disabled && vtrack.Frame == null)
                            {
                                vtrack.Frame = vsplit.GetFrame();
                            }

                            if (atrack.Index != TrackState.Disabled && atrack.Frame == null)
                            {
                                atrack.Frame = asplit.GetFrame();
                            }

                            TrackState track = SelectMuxTrack(vtrack, atrack);

                            if (track == null)
                            {
                                break;
                            }

                            // log
                            if (track.Frame != null)
                            {
                                if (track.Frame.StartTime - track.Progress >= 1.0)
                                {
                                    track.Progress = track.Frame.StartTime;
                                    Console.WriteLine("track {0} frame #{1} pts:{2}", track.Index, track.FrameCount, track.Frame.StartTime);
                                }
                            }
                            else
                            {
                                Console.WriteLine("track {0} eos", track.Index);
                            }

                            if (track.Frame != null)
                            {
                                res = transcoder.Push(track.Index, track.Frame);
                                if (!res)
                                {
                                    PrintError("transcoder push frame", transcoder.Error);
                                    return(false);
                                }
                                track.Frame = null; // clear the muxed frame in order to read to the next one
                                track.FrameCount++;
                            }
                            else
                            {
                                res = transcoder.Push(track.Index, null);
                                if (!res)
                                {
                                    PrintError("transcoder push eos", transcoder.Error);
                                    return(false);
                                }
                                track.Index = TrackState.Disabled; // disable track
                            }
                        }

                        res = transcoder.Flush();
                        if (!res)
                        {
                            PrintError("transcoder flush", transcoder.Error);
                            return(false);
                        }
                        transcoder.Close();
                    }

            return(true);
        }
예제 #16
0
        static bool Encode(Options opt)
        {
            string       outFilename    = "cube." + opt.FileExtension;
            const int    imageCount     = 250;
            const double inputFrameRate = 25.0;

            using (var transcoder = new Transcoder())
            {
                // In order to use the OEM release for testing (without a valid license),
                // the transcoder demo mode must be enabled.
                transcoder.AllowDemoMode = true;

                try
                {
                    bool result;

                    try
                    {
                        File.Delete(outFilename);
                    }catch {}

                    // Configure Input
                    {
                        using (MediaInfo medInfo = new MediaInfo())
                        {
                            medInfo.Inputs[0].File = GetImagePath(0);

                            result = medInfo.Open();
                            PrintError("Open MediaInfo", medInfo.Error);
                            if (!result)
                            {
                                return(false);
                            }

                            VideoStreamInfo vidInfo = (VideoStreamInfo)medInfo.Outputs[0].Pins[0].StreamInfo.Clone();
                            vidInfo.FrameRate = inputFrameRate;

                            MediaPin pin = new MediaPin();
                            pin.StreamInfo = vidInfo;

                            MediaSocket socket = new MediaSocket();
                            socket.Pins.Add(pin);

                            transcoder.Inputs.Add(socket);
                        }
                    }

                    // Configure Output
                    {
                        MediaSocket socket = MediaSocket.FromPreset(opt.PresetID);
                        socket.File = outFilename;

                        transcoder.Outputs.Add(socket);
                    }

                    // Encode Images
                    result = transcoder.Open();
                    PrintError("Open Transcoder", transcoder.Error);
                    if (!result)
                    {
                        return(false);
                    }

                    for (int i = 0; i < imageCount; i++)
                    {
                        string imagePath = GetImagePath(i);

                        MediaBuffer mediaBuffer = new MediaBuffer(File.ReadAllBytes(imagePath));

                        MediaSample mediaSample = new MediaSample();
                        mediaSample.StartTime = i / inputFrameRate;
                        mediaSample.Buffer    = mediaBuffer;

                        if (!transcoder.Push(0, mediaSample))
                        {
                            PrintError("Push Transcoder", transcoder.Error);
                            return(false);
                        }
                    }

                    result = transcoder.Flush();
                    PrintError("Flush Transcoder", transcoder.Error);
                    if (!result)
                    {
                        return(false);
                    }

                    transcoder.Close();
                    Console.WriteLine("Output video: \"{0}\"", outFilename);
                }
                catch (Exception ex)
                {
                    Console.WriteLine(ex.ToString());
                    return(false);
                }
            }

            return(true);
        }
예제 #17
0
        static bool MP4Remux(Options opt)
        {
            try { File.Delete(opt.OutputFile); }
            catch (Exception) { }

            bool audioStreamDetected = false;
            bool videoStreamDetected = false;

            using (var transcoder = new Transcoder())
            {
                // Transcoder demo mode must be enabled,
                // in order to use the production release for testing (without a valid license).
                transcoder.AllowDemoMode = true;

                // configure inputs
                using (MediaInfo info = new MediaInfo())
                {
                    info.Inputs[0].File = opt.InputFile;

                    if (!info.Open())
                    {
                        PrintError("mediaInfo.Open", info.Error);
                        return(false);
                    }

                    MediaSocket inputSocket = MediaSocket.FromMediaInfo(info);
                    info.Close();

                    for (int i = 0; i < inputSocket.Pins.Count; i++)
                    {
                        MediaPin pin = inputSocket.Pins[i];

                        if (pin.StreamInfo.StreamType == StreamType.H264)
                        {
                            if (videoStreamDetected)
                            {
                                pin.Connection = PinConnection.Disabled;
                            }
                            else
                            {
                                videoStreamDetected = true;
                                Console.WriteLine("Muxing video input: {0}", opt.InputFile);
                            }
                        }
                        else if (pin.StreamInfo.StreamType == StreamType.Aac)
                        {
                            if (audioStreamDetected)
                            {
                                pin.Connection = PinConnection.Disabled;
                            }
                            else
                            {
                                audioStreamDetected = true;
                                Console.WriteLine("Muxing audio input: {0}", opt.InputFile);
                            }
                        }
                        else
                        {
                            pin.Connection = PinConnection.Disabled;
                        }
                    }

                    transcoder.Inputs.Add(inputSocket);
                }

                // Configure output
                {
                    MediaSocket socket = new MediaSocket();
                    socket.File       = opt.OutputFile;
                    socket.StreamType = StreamType.Mp4;

                    if (videoStreamDetected)
                    {
                        VideoStreamInfo streamInfo = new VideoStreamInfo();
                        streamInfo.StreamType    = StreamType.H264;
                        streamInfo.StreamSubType = StreamSubType.Avc1;

                        MediaPin pin = new MediaPin();
                        pin.StreamInfo = streamInfo;
                        socket.Pins.Add(pin);
                    }

                    if (audioStreamDetected)
                    {
                        AudioStreamInfo streamInfo = new AudioStreamInfo();
                        streamInfo.StreamType    = StreamType.Aac;
                        streamInfo.StreamSubType = StreamSubType.AacMp4;

                        MediaPin pin = new MediaPin();
                        pin.StreamInfo = streamInfo;
                        socket.Pins.Add(pin);
                    }

                    if (opt.FastStart)
                    {
                        socket.Params.Add(Param.Muxer.MP4.FastStart, 1);
                    }

                    transcoder.Outputs.Add(socket);
                }

                bool res = transcoder.Open();
                PrintError("Open Transcoder", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                res = transcoder.Run();
                PrintError("Run Transcoder", transcoder.Error);
                if (!res)
                {
                    return(false);
                }

                transcoder.Close();
            }

            return(true);
        }
예제 #18
0
        public bool TranscodeSplit(Options opt, string outFile, string preset, double startTime,
                                   out double processedTime, out Int64 processedSize, out bool isSplit)
        {
            DeleteFile(outFile);
            processedSize = 0;
            processedTime = 0;
            isSplit       = false;

            using (var transcoder = new Transcoder()
            {
                AllowDemoMode = true
            })
            {
                // Input
                var inSocket = new MediaSocket();
                inSocket.File         = opt.InputFile;
                inSocket.TimePosition = startTime;
                transcoder.Inputs.Add(inSocket);

                using (var outputStream = new OutputStream(outFile))
                {
                    // Output
                    MediaSocket outSocket = MediaSocket.FromPreset(preset);
                    outSocket.Stream = outputStream;
                    transcoder.Outputs.Add(outSocket);

                    outputStream_          = outputStream;
                    transcoder.OnContinue += Transcoder_OnContinue;
                    transcoder.OnProgress += Transcoder_OnProgress;
                    ReportProgress         = false;

                    if (opt.SplitTime > 0)
                    {
                        SplitTime = opt.SplitTime;
                    }

                    if (opt.SplitSize > 0)
                    {
                        SplitSize = opt.SplitSize;
                    }

                    if (!transcoder.Open())
                    {
                        PrintError("Transcoder open", transcoder.Error);
                        return(false);
                    }

                    if (!transcoder.Run())
                    {
                        PrintError("Transcoder run", transcoder.Error);
                        return(false);
                    }

                    transcoder.Close();
                    isSplit       = isSplit_;
                    processedSize = outputStream.Length;
                    processedTime = processedTime_;
                }
            }

            return(true);
        }
예제 #19
0
 public void Close()
 {
     t.Close();
     t.Inputs.Clear();
     t.Outputs.Clear();
 }
예제 #20
0
        static bool MP4Mux(Options opt)
        {
            try { File.Delete(opt.OutputFile); }
            catch (Exception) { }

            using (var transcoder = new Transcoder())
            {
                // Transcoder demo mode must be enabled,
                // in order to use the production release for testing (without a valid license)
                transcoder.AllowDemoMode = true;

                MediaSocket outputSocket = new MediaSocket();
                outputSocket.File       = opt.OutputFile;
                outputSocket.StreamType = StreamType.Mp4;

                // audio
                for (int i = 0; i < (int)opt.AudioFiles.Length; i++)
                {
                    MediaPin        outputPin = new MediaPin();
                    AudioStreamInfo asi       = new AudioStreamInfo();
                    asi.StreamType       = StreamType.Aac;
                    outputPin.StreamInfo = asi;

                    outputSocket.Pins.Add(outputPin);

                    MediaSocket inputSocket = new MediaSocket();
                    inputSocket.File       = opt.AudioFiles[i];
                    inputSocket.StreamType = StreamType.Mp4;
                    transcoder.Inputs.Add(inputSocket);

                    Console.WriteLine("Muxing audio input: {0}", opt.AudioFiles[i]);
                }

                // video
                for (int i = 0; i < (int)opt.VideoFiles.Length; i++)
                {
                    MediaPin        outputPin = new MediaPin();
                    VideoStreamInfo vsi       = new VideoStreamInfo();
                    vsi.StreamType       = StreamType.H264;
                    outputPin.StreamInfo = vsi;

                    outputSocket.Pins.Add(outputPin);

                    MediaSocket inputSocket = new MediaSocket();
                    inputSocket.File       = opt.VideoFiles[i];
                    inputSocket.StreamType = StreamType.Mp4;
                    transcoder.Inputs.Add(inputSocket);

                    Console.WriteLine("Muxing video input: {0}", opt.VideoFiles[i]);
                }

                transcoder.Outputs.Add(outputSocket);

                if (!transcoder.Open())
                {
                    PrintError("Open Transcoder", transcoder.Error);
                    return(false);
                }

                if (!transcoder.Run())
                {
                    PrintError("Run Transcoder", transcoder.Error);
                    return(false);
                }

                transcoder.Close();

                Console.WriteLine("Output file: {0}", opt.OutputFile);

                return(true);
            }
        }
예제 #21
0
        static bool DecodeH264Stream(Options opt)
        {
            // Create an input socket from file
            MediaSocket inSocket = new MediaSocket();

            inSocket.File = opt.InputFile;

            // Create an output socket with one YUV 4:2:0 video pin
            VideoStreamInfo outStreamInfo = new VideoStreamInfo();

            outStreamInfo.StreamType  = StreamType.UncompressedVideo;
            outStreamInfo.ColorFormat = ColorFormat.YUV420;
            outStreamInfo.ScanType    = ScanType.Progressive;

            MediaPin outPin = new MediaPin();

            outPin.StreamInfo = outStreamInfo;

            MediaSocket outSocket = new MediaSocket();

            outSocket.StreamType = StreamType.UncompressedVideo;

            outSocket.Pins.Add(outPin);

            // Create Transcoder
            using (var transcoder = new Transcoder())
            {
                transcoder.AllowDemoMode = true;
                transcoder.Inputs.Add(inSocket);
                transcoder.Outputs.Add(outSocket);

                if (transcoder.Open())
                {
                    DeleteFile(opt.OutputFile);

                    int         inputIndex;
                    MediaSample yuvFrame = new MediaSample();

                    int frameCounter = 0;

                    using (System.IO.FileStream outfile = System.IO.File.OpenWrite(opt.OutputFile))
                    {
                        while (transcoder.Pull(out inputIndex, yuvFrame))
                        {
                            // Each call to Transcoder::pull returns a raw YUV 4:2:0 frame.
                            outfile.Write(yuvFrame.Buffer.Start, yuvFrame.Buffer.DataOffset, yuvFrame.Buffer.DataSize);
                            ++frameCounter;
                        }

                        PrintError("Transcoder pull", transcoder.Error);

                        Console.WriteLine("Frames decoded: {0}", frameCounter);
                        Console.WriteLine("Output file: {0}", opt.OutputFile);


                        outfile.Close();
                    }

                    transcoder.Close();
                    return(true);
                }

                PrintError("Transcoder open", transcoder.Error);

                return(false);
            }
        }
예제 #22
0
        static void EncodeDirectShowInput(string inputFile, string outputFile, string preset)
        {
            if (File.Exists(outputFile))
            {
                File.Delete(outputFile);
            }

            DSGraph    dsGraph    = new DSGraph();
            Transcoder transcoder = new Transcoder();

            // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
            transcoder.AllowDemoMode = true;

            try
            {
                Console.WriteLine("Initializing DirectShow graph.");

                /*
                 *  If the source is a DirectShow filter instead of a file then:
                 * 1) Create an instance of the source filter
                 * 2) Configure source filter
                 * 3) Call dsGraph.Init(sourceFilter);
                 *
                 * For example dsGraph.Init(inputFile) can be replaced with the following code:
                 *
                 *   1) Create an instance of the source filter
                 *
                 *      // FileSourceAsync filter
                 *      IBaseFilter sourceFilter = Util.CreateFilter(new Guid("e436ebb5-524f-11ce-9f53-0020af0ba770"));
                 *
                 *      // or WM ASF Reader filter
                 *      IBaseFilter sourceFilter = Util.CreateFilter(new Guid("187463A0-5BB7-11D3-ACBE-0080C75E246E"));
                 *
                 *   2) Configure source filter
                 *      IFileSourceFilter fileSourceFilter = sourceFilter as IFileSourceFilter;
                 *      fileSourceFilter.Load(inputFile, null);
                 *
                 *   3)
                 *      dsGraph.Init(sourceFilter);
                 */

                dsGraph.Init(inputFile);

                if (dsGraph.videoGrabber != null)
                {
                    ConfigureVideoInput(dsGraph, transcoder);
                }

                if (dsGraph.audioGrabber != null)
                {
                    ConfigureAudioInput(dsGraph, transcoder);
                }

                if ((dsGraph.videoGrabber == null) && (dsGraph.audioGrabber == null))
                {
                    Console.WriteLine("No audio or video can be read from the DirectShow graph.");
                    return;
                }

                // Configure output
                {
                    MediaSocket outSocket = MediaSocket.FromPreset(preset);
                    outSocket.File = outputFile;
                    transcoder.Outputs.Add(outSocket);
                }

                bool res = transcoder.Open();

                PrintError("Open Transcoder", transcoder.Error);
                if (!res)
                {
                    return;
                }

                //DBG
                //var rot = new DsROTEntry(dsGraph.graph);

                Console.WriteLine("Running DirectShow graph.");
                int hr = dsGraph.mediaControl.Run();
                DsError.ThrowExceptionForHR(hr);

                while (true)
                {
                    FilterState fs;
                    dsGraph.mediaControl.GetState(-1, out fs);

                    if (fs != FilterState.Running)
                    {
                        break;
                    }

                    EventCode ev;
                    dsGraph.mediaEvent.WaitForCompletion(1000, out ev);

                    if (EventCode.Complete == ev)
                    {
                        break;
                    }
                }

                Console.WriteLine("DirectShow graph is stopped.");

                if ((dsGraph.videoGrabberCB != null) && (dsGraph.videoGrabberCB.TranscoderError != null))
                {
                    PrintError("Transcoder Error", transcoder.Error);
                }

                if ((dsGraph.audioGrabberCB != null) && (dsGraph.audioGrabberCB.TranscoderError != null))
                {
                    PrintError("Transcoder Error", transcoder.Error);
                }

                Console.WriteLine("Closing transcoder.");

                if (!transcoder.Flush())
                {
                    PrintError("Flush Transcoder", transcoder.Error);
                }

                transcoder.Close();
            }
            finally
            {
                dsGraph.Reset();
                transcoder.Dispose();
            }
        }
예제 #23
0
        static bool ReEncode(Options opt)
        {
            if (File.Exists(opt.OutputFile))
            {
                File.Delete(opt.OutputFile);
            }

            using (var transcoder = new Transcoder())
            {
                // In order to use the production release for testing (without a valid license),
                // the transcoder demo mode must be enabled.
                transcoder.AllowDemoMode = true;

                using (var mediaInfo = new MediaInfo())
                {
                    mediaInfo.Inputs[0].File = opt.InputFile;

                    if (!mediaInfo.Open())
                    {
                        PrintError("Open MediaInfo", mediaInfo.Error);
                        return(false);
                    }

                    // Add Inputs
                    {
                        var socket = MediaSocket.FromMediaInfo(mediaInfo);
                        transcoder.Inputs.Add(socket);
                    }
                }

                // Add Outputs
                {
                    // Create output socket
                    var socket   = new MediaSocket();
                    var inSocket = transcoder.Inputs[0];

                    socket.StreamType = inSocket.StreamType;
                    socket.File       = opt.OutputFile;

                    // Add pins with ReEncode parameter set to Use.On
                    foreach (var inPin in inSocket.Pins)
                    {
                        StreamInfo si  = (StreamInfo)inPin.StreamInfo.Clone();
                        var        pin = new MediaPin();
                        pin.StreamInfo = (StreamInfo)si.Clone();

                        if ((MediaType.Video == si.MediaType) && opt.ReEncodeVideo)
                        {
                            pin.Params.Add(Param.ReEncode, Use.On);
                        }

                        if ((MediaType.Audio == si.MediaType) && opt.ReEncodeAudio)
                        {
                            pin.Params.Add(Param.ReEncode, Use.On);
                        }

                        socket.Pins.Add(pin);
                    }

                    transcoder.Outputs.Add(socket);
                }


                bool result = transcoder.Open();
                PrintError("Open Transcoder", transcoder.Error);
                if (!result)
                {
                    return(false);
                }

                result = transcoder.Run();
                PrintError("Run Transcoder", transcoder.Error);
                if (!result)
                {
                    return(false);
                }

                transcoder.Close();
            }

            return(true);
        }
예제 #24
0
        static bool SplitFile(string inputFile)
        {
            string       outputFileExt     = ".mpg";
            string       encodingPreset    = Preset.Video.DVD.NTSC_4x3_PCM;
            const double splitPartDuration = 10;     // seconds

            int audioStreamIndex = -1;
            int videoStreamIndex = -1;

            int audioFrameSize  = 0;
            int audioSampleRate = 0;

            using (var transcoder1 = new Transcoder())
            {
                // In order to use the OEM release for testing (without a valid license) the transcoder demo mode must be enabled.
                transcoder1.AllowDemoMode = true;

                using (var inputInfo = new MediaInfo())
                {
                    inputInfo.Inputs[0].File = inputFile;
                    if (!inputInfo.Open())
                    {
                        PrintError("Open MediaInfo", inputInfo.Error);
                        return(false);
                    }

                    // Configure transcoder1 input and output
                    var inputSocket = MediaSocket.FromMediaInfo(inputInfo);
                    transcoder1.Inputs.Add(inputSocket);

                    for (int i = 0; i < inputSocket.Pins.Count; i++)
                    {
                        StreamInfo inputStreamInfo = inputSocket.Pins[i].StreamInfo;

                        if ((inputStreamInfo.MediaType == MediaType.Video) && videoStreamIndex < 0)
                        {
                            var streamInfo = new VideoStreamInfo();

                            VideoStreamInfo inputVideoStreamInfo = inputStreamInfo as VideoStreamInfo;

                            streamInfo.ColorFormat = ColorFormat.YUV420;
                            streamInfo.StreamType  = StreamType.UncompressedVideo;
                            streamInfo.ScanType    = inputVideoStreamInfo.ScanType;

                            streamInfo.FrameWidth         = inputVideoStreamInfo.FrameWidth;
                            streamInfo.FrameHeight        = inputVideoStreamInfo.FrameHeight;
                            streamInfo.DisplayRatioWidth  = inputVideoStreamInfo.DisplayRatioWidth;
                            streamInfo.DisplayRatioHeight = inputVideoStreamInfo.DisplayRatioHeight;

                            var outputPin = new MediaPin();
                            outputPin.StreamInfo = streamInfo;

                            var outputSocket = new MediaSocket();
                            outputSocket.Pins.Add(outputPin);
                            outputSocket.StreamType = streamInfo.StreamType;

                            videoStreamIndex = transcoder1.Outputs.Count;
                            transcoder1.Outputs.Add(outputSocket);
                        }

                        if ((inputStreamInfo.MediaType == MediaType.Audio) && audioStreamIndex < 0)
                        {
                            var streamInfo = new AudioStreamInfo();

                            AudioStreamInfo inputAudioStreamInfo = inputStreamInfo as AudioStreamInfo;

                            streamInfo.StreamType = StreamType.LPCM;

                            streamInfo.PcmFlags      = inputAudioStreamInfo.PcmFlags;
                            streamInfo.Channels      = inputAudioStreamInfo.Channels;
                            streamInfo.SampleRate    = inputAudioStreamInfo.SampleRate;
                            streamInfo.BitsPerSample = inputAudioStreamInfo.BitsPerSample;

                            var outputPin = new MediaPin();
                            outputPin.StreamInfo = streamInfo;

                            var outputSocket = new MediaSocket();
                            outputSocket.Pins.Add(outputPin);
                            outputSocket.StreamType = streamInfo.StreamType;

                            audioStreamIndex = transcoder1.Outputs.Count;
                            transcoder1.Outputs.Add(outputSocket);

                            audioFrameSize  = inputAudioStreamInfo.Channels * inputAudioStreamInfo.BitsPerSample / 8;
                            audioSampleRate = inputAudioStreamInfo.SampleRate;
                        }
                    }
                }

                bool res = transcoder1.Open();
                PrintError("Open Transcoder1", transcoder1.Error);
                if (!res)
                {
                    return(false);
                }

                var sample = new MediaSample();
                int outputIndex;

                int        splitPartNum  = 0;
                double     splitTime     = splitPartDuration;
                double     partStartTime = 0;
                Transcoder transcoder2   = null;

                List <SplitRecord> splitStats = new List <SplitRecord>();

                List <MediaSample> audioSamplesQueue = new List <MediaSample>();

                try
                {
                    for (; ;)
                    {
                        if ((audioSamplesQueue.Count > 0) && (audioSamplesQueue[0].StartTime < splitTime))
                        {
                            outputIndex = audioStreamIndex;
                            sample      = audioSamplesQueue[0];
                            audioSamplesQueue.RemoveAt(0);
                        }
                        else
                        {
                            if (!transcoder1.Pull(out outputIndex, sample))
                            {
                                break;
                            }

                            if ((outputIndex != audioStreamIndex) &&
                                (outputIndex != videoStreamIndex))
                            {
                                continue;
                            }
                        }

                        if (outputIndex == audioStreamIndex)
                        {
                            double sampleDuration = (double)(sample.Buffer.DataSize) / (double)(audioFrameSize * audioSampleRate);
                            if (sample.StartTime >= splitTime)
                            {
                                audioSamplesQueue.Add(sample);
                                sample = new MediaSample();
                                continue;
                            }
                            else if ((sample.StartTime + sampleDuration) > splitTime)
                            {
                                double sample1Duration   = splitTime - sample.StartTime;
                                int    sample1BufferSize = (int)(sample1Duration * audioSampleRate) * audioFrameSize;

                                if (sample1BufferSize < sample.Buffer.DataSize)
                                {
                                    int buffer2Size = sample.Buffer.DataSize - sample1BufferSize;
                                    var buffer2     = new MediaBuffer(new byte[buffer2Size]);
                                    buffer2.SetData(0, buffer2Size);

                                    Array.Copy(sample.Buffer.Start, sample1BufferSize, buffer2.Start, 0, buffer2Size);

                                    var sample2 = new MediaSample();
                                    sample2.StartTime = sample.StartTime + sample1Duration;
                                    sample2.Buffer    = buffer2;

                                    if (sample1BufferSize > 0)
                                    {
                                        sample.Buffer.SetData(sample.Buffer.DataOffset, sample1BufferSize);
                                    }
                                    else
                                    {
                                        sample.Buffer.SetData(0, 0);
                                    }

                                    audioSamplesQueue.Add(sample2);
                                }
                            }
                        }


                        if ((transcoder2 == null) ||
                            ((sample.StartTime + 0.0001 >= splitTime) && (outputIndex == videoStreamIndex)))
                        {
                            if (transcoder2 != null)
                            {
                                transcoder2.Flush();
                                transcoder2.Close();
                                transcoder2.Dispose();
                            }

                            SplitRecord splitStat = new SplitRecord();
                            splitStat.StartTime       = splitTime;
                            splitStat.StartTimeActual = sample.StartTime;

                            splitPartNum += 1;
                            splitTime     = splitPartNum * splitPartDuration;
                            partStartTime = sample.StartTime;

                            transcoder2 = new Transcoder();
                            transcoder2.AllowDemoMode = true;

                            // Configure transcoder2 input and output
                            {
                                for (int i = 0; i < transcoder1.Outputs.Count; i++)
                                {
                                    var streamInfo = transcoder1.Outputs[i].Pins[0].StreamInfo.Clone() as StreamInfo;
                                    var pin        = new MediaPin();
                                    pin.StreamInfo = streamInfo;

                                    var socket = new MediaSocket();
                                    socket.Pins.Add(pin);
                                    socket.StreamType = streamInfo.StreamType;

                                    transcoder2.Inputs.Add(socket);
                                }

                                var outputSocket = MediaSocket.FromPreset(encodingPreset);

                                string fileName = GenerateOutputFileName(inputFile, splitPartNum) + outputFileExt;
                                string filePath = Path.Combine(GetExeDir(), fileName);

                                try
                                {
                                    File.Delete(filePath);
                                }
                                catch { }

                                outputSocket.File = filePath;
                                transcoder2.Outputs.Add(outputSocket);

                                splitStat.FileName = fileName;
                            }

                            if (splitStats.Count > 0)
                            {
                                SplitRecord lastRecord = splitStats[splitStats.Count - 1];
                                lastRecord.EndTime       = splitStat.StartTime;
                                lastRecord.EndTimeActual = splitStat.StartTimeActual;
                            }

                            splitStats.Add(splitStat);

                            res = transcoder2.Open();
                            PrintError("Open Transcoder2", transcoder2.Error);
                            if (!res)
                            {
                                return(false);
                            }
                        }

                        if ((splitStats.Count > 0))
                        {
                            SplitRecord lastRecord = splitStats[splitStats.Count - 1];
                            lastRecord.EndTime       = sample.StartTime;
                            lastRecord.EndTimeActual = lastRecord.EndTime;
                        }

                        if (sample.StartTime >= 0)
                        {
                            sample.StartTime = sample.StartTime - partStartTime;
                        }

                        res = transcoder2.Push(outputIndex, sample);
                        if (!res)
                        {
                            PrintError("Push Transcoder2", transcoder2.Error);
                            return(false);
                        }
                    }
                }
                finally
                {
                    if (transcoder2 != null)
                    {
                        transcoder2.Flush();
                        transcoder2.Close();
                        transcoder2.Dispose();
                        transcoder2 = null;
                    }
                }

                if ((transcoder1.Error.Facility != ErrorFacility.Codec) ||
                    (transcoder1.Error.Code != (int)CodecError.EOS))
                {
                    PrintError("Pull Transcoder1", transcoder1.Error);
                    return(false);
                }

                transcoder1.Close();

                // print split stats
                Console.WriteLine();
                foreach (var record in splitStats)
                {
                    Console.WriteLine("{0} start: {1} end: {2} act. start: {3} act. end: {4}", record.FileName,
                                      FormatTime(record.StartTime), FormatTime(record.EndTime), FormatTime(record.StartTimeActual), FormatTime(record.EndTimeActual));
                }
                Console.WriteLine();
            }

            return(true);
        }