PPT转MP4--.NET实现

去年接了个没给钱的私活，就是做这么一个东西，最后也没着落了，今天就把代码发出来大家分享下。

为了，凑字数，直接贴代码：

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;
using System.Threading;
using Microsoft.Office.Core;
using PowerPoint = Microsoft.Office.Interop.PowerPoint;
using System.Diagnostics;
using ThreadState = System.Threading.ThreadState;
using System.IO;

namespace PPT2Image
{
    static class Program
    {
        [DllImport("Gdi32.dll")]
        private static extern int BitBlt(IntPtr hDC, int x, int y, int nWidth, int nHeight, IntPtr hSrcDC, int xSrc, int ySrc, int dwRop);

        private static Object obj = new object();
        /// <summary>
        /// 图片集合
        /// </summary>
        private static Queue<Bitmap> _imageList = new Queue<Bitmap>();
        /// <summary>
        /// 索引表
        /// </summary>
        private static Dictionary<Int32, IndexObject> _indexs = new Dictionary<Int32, IndexObject>();
        /// <summary>
        /// 每页等待时间
        /// </summary>
        private static Int32 deplyTime = 3000;

        private static PowerPoint.Application _objApp;
        private static PowerPoint._Presentation _objPres;

        private static Int32 width = Int32.Parse(ConfigurationManager.AppSettings["width"]);
        private static Int32 height = Int32.Parse(ConfigurationManager.AppSettings["height"]);

        /// <summary>
        /// 图片全局索引
        /// </summary>
        private static Int32 _index = 1;
        /// <summary>
        /// 图片前一个全局索引
        /// </summary>
        private static Int32 _prev_index = 1;

        // 图片的流水号
        private static Int32 _view_index = 1;
        // 图片对应的PPT页面编号
        private static Int32 _slide_index = -1;
        // 图片对应的前一个PPT页面编号
        private static Int32 _prev_slide_index = 1;

        /// <summary>
        /// 每秒图片张数
        /// </summary>
        //private static Int32 ImageNum = 20;

        private static String _noteFilePath;
        private static String _resultFilePath;
        private static String _outputPath;
        private static String _filePath;

        /// <summary>
        /// 索引对象
        /// </summary>
        private class IndexObject
        {
            /// <summary>
            /// PPT页索引
            /// </summary>
            public Int32 SlideIndex { get; set; }
            /// <summary>
            /// PPT页动画索引
            /// </summary>
            public Int32 ViewIndex { get; set; }
        }

        private static Int32 PixelsToPoints(Int32 val, Boolean vert)
        {
            Double result;
            if (vert)
            {
                result = Math.Truncate(val * 0.75);
            }
            else
            {
                result = Math.Truncate(val * 0.75);
            }

            return (Int32)result;
        }

        static void Main(string[] args)
        {
            ParseArgs(args);

            var fileName = Path.GetFileNameWithoutExtension(_filePath);

            _noteFilePath = Path.Combine(_outputPath, fileName + "_note.txt");
            _resultFilePath = Path.Combine(_outputPath, fileName + "_result.txt");

            if (!Directory.Exists(Path.Combine(_outputPath, "images")))
            {
                Directory.CreateDirectory(Path.Combine(_outputPath, "images"));
            }

            var imgsPath = Path.Combine(_outputPath, "images.jpg");
            try
            {
                _objApp = new PowerPoint.Application();
                _objPres = _objApp.Presentations.Open(_filePath, WithWindow: MsoTriState.msoFalse);

                _objPres.SaveAs(imgsPath, PowerPoint.PpSaveAsFileType.ppSaveAsPNG, MsoTriState.msoTrue);


                // 保存备注
                SaveNoteInfo();

                // 设置呈现窗口
                SetSildeShowWindow();

                var pptRenderThread = InitPPTRenderThread();
                var imageSaveThread = InitImageSaveThread();

                pptRenderThread.Start();
                imageSaveThread.Start();

                while (_objApp.SlideShowWindows.Count >= 1) Thread.Sleep(deplyTime / 10);

                pptRenderThread.Abort();
                //pptRenderThread.Join();
                imageSaveThread.Abort();
                //imageSaveThread.Join();

                _objPres.Save();

                _objApp.Quit();
            }
            catch (Exception ex)
            {
                Console.WriteLine(ex.Message);
            }

            // 杀死powerpnt
            KillProcess("powerpnt");

            SaveResult();

            // 退出
            Environment.Exit(0);
        }

        /// <summary>
        /// 杀死进程
        /// </summary>
        /// <param name="processName"></param>
        private static void KillProcess(String processName)
        {
            foreach (var process in Process.GetProcesses())
            {
                if (process.ProcessName.ToLower().Contains(processName))
                {
                    process.Kill();
                }
            }
        }

        /// <summary>
        /// 初始化参数
        /// </summary>
        private static void ParseArgs(String[] args)
        {
            // 文件路径
            _filePath = args[1];
            // 输出路径
            _outputPath = args[3];
        }

        /// <summary>
        /// 保存结果
        /// </summary>
        private static void SaveResult()
        {
            var stream = new FileStream(_resultFilePath, FileMode.Create);
            var writer = new StreamWriter(stream);

            var prevSlideIndex = 0;

            // key是图片节点信息
            foreach (var key in _indexs.Keys)
            {
                if (_indexs[key].SlideIndex != prevSlideIndex)
                {
                    // 前一个key与后一个key之间的图片为一组
                    writer.WriteLine(_indexs[key].SlideIndex + "-" + _indexs[key].ViewIndex);
                }
                else
                {
                    // 前一个key与后一个key之间的图片为一组
                    writer.WriteLine(_indexs[key].SlideIndex + "-" + _indexs[key].ViewIndex);
                }

                writer.Flush();
                stream.Flush();
            }

            writer.Close();
            stream.Close();

            writer.Dispose();
            stream.Dispose();
        }

        /// <summary>
        /// 初始化图片保存线程
        /// </summary>
        /// <returns></returns>
        private static Thread InitImageSaveThread()
        {
            var imageIndex = 1;
            var imageSaveThread = new Thread(() =>
                {
                    while (true)
                    {
                        if (_imageList.Count == 0) continue;
                        lock (obj)
                        {
                            var bmp = _imageList.Dequeue();
                            using (var stream = new FileStream(Path.Combine(_outputPath, imageIndex.ToString("0000") + ".jpg"), FileMode.Create))
                            {
                                bmp.Save(stream, ImageFormat.Jpeg);

                                bmp.Dispose();
                            }

                            imageIndex++;
                        }
                    }
                });

            return imageSaveThread;
        }


        /// <summary>
        /// 初始化抓图线程
        /// </summary>
        /// <param name="objPres"></param>
        /// <returns></returns>
        private static Thread InitCaptureThread(PowerPoint._Presentation objPres)
        {
            var thread = new Thread(() =>
            {
                while (true)
                {
                    try
                    {
                        var bmp = new Bitmap(width, height);
                        Graphics gSrc = Graphics.FromHwnd((IntPtr)objPres.SlideShowWindow.HWND);
                        IntPtr hdcSrc = gSrc.GetHdc();
                        Graphics gDes = Graphics.FromImage(bmp);
                        IntPtr hdcDes = gDes.GetHdc();

                        BitBlt(hdcDes, 0, 0, width, height, hdcSrc, 0, 0,
                               (int)(CopyPixelOperation.SourceCopy));

                        gSrc.ReleaseHdc(hdcSrc);
                        gDes.ReleaseHdc(hdcDes);
                        gSrc.Dispose();
                        gDes.Dispose();

                        _imageList.Enqueue(bmp);
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }

                    // 截取140张 退出线程
//                    if (_index % 140 == 0)
//                    {
//                        // 图片索引+1
//                        _index++;
//
//                        Thread.CurrentThread.Abort();
//
//                        return;
//                    }

                    // 图片索引+1
                    _index++;

                    // 修改暂停时间
                    Thread.Sleep(35);
                }
            });

            // 设置最大优先级
            thread.Priority = ThreadPriority.Highest;

            return thread;
        }

        /// <summary>
        /// 初始化PPT呈现线程
        /// </summary>
        /// <returns></returns>
        private static Thread InitPPTRenderThread()
        {
            var pptRenderThread = new Thread(() =>
                {
                    // 第一次
                    Thread thread = InitCaptureThread(_objPres);

                    try
                    {
                        if (_slide_index == -1)
                        {
                            _slide_index = 1;
                            _objPres.SlideShowWindow.View.First();
                            _objPres.SlideShowWindow.View.GotoSlide(1);
                            _objPres.SlideShowWindow.View.ResetSlideTime();

                            // 前一个全局索引等于_index
                            _prev_index = _index;

                            _indexs.Add(_index, new IndexObject()
                                {
                                    SlideIndex = _slide_index,
                                    ViewIndex = _view_index
                                });

                            thread.Start();
                        }
                    }
                    catch (Exception ex)
                    {
                        Console.WriteLine(ex.Message);
                    }

                    while (true)
                    {
                        try
                        {
                            // 等待3秒
                            Thread.Sleep(deplyTime);

                            //if (thread.ThreadState == ThreadState.Running
                            //    || thread.ThreadState != ThreadState.Unstarted)
                            //{
                            _view_index++;

                            if (thread.ThreadState != ThreadState.Aborted)
                            {
                                thread.Abort();
                            }
                            thread = InitCaptureThread(_objPres);

                            // 前一个全局索引等于_index
                            _prev_index = _index;

                            // 启动之前，保存索引信息
                            _indexs.Add(_index, new IndexObject()
                            {
                                SlideIndex = _slide_index,
                                ViewIndex = _view_index
                            });

                            thread.Start();
                            //}

                            // 下一个动画页面
                            _objPres.SlideShowWindow.View.Next();

                            if (_slide_index != -1)
                            {
                                // 获取当前PPT索引,第几张PPT
                                _slide_index = _objPres.SlideShowWindow.View.Slide.SlideIndex;

                                if (_prev_slide_index != _slide_index)
                                {
                                    _view_index = 1;
                                    _prev_slide_index = _slide_index;

                                    // 修改前一个全局索引对应的值
                                    _indexs[_prev_index] = new IndexObject()
                                        {
                                            SlideIndex = _slide_index,
                                            ViewIndex = _view_index
                                        };
                                }
                            }
                        }
                        catch (Exception ex)
                        {
                            Console.WriteLine(ex.Message);
                        }
                    }
                });

            pptRenderThread.Priority = ThreadPriority.Highest;

            return pptRenderThread;
        }

        /// <summary>
        /// 设置呈现窗口
        /// </summary>
        private static void SetSildeShowWindow()
        {
            // 起始页面索引
            _objPres.SlideShowSettings.StartingSlide = 1;
            // 结束页面索引
            _objPres.SlideShowSettings.EndingSlide = _objPres.Slides.Count;
            // 放映开始
            _objPres.SlideShowSettings.Run();

            // 设置放映窗口宽度
            _objPres.SlideShowWindow.Width = PixelsToPoints(width, false);
            // 设置放映窗口高度
            _objPres.SlideShowWindow.Height = PixelsToPoints(height, true);
            // 设置放映窗口Top
            _objPres.SlideShowWindow.Top = 0;
            // 设置放映窗口Left
            _objPres.SlideShowWindow.Left = 0;
        }

        /// <summary>
        /// 保存备注信息
        /// </summary>
        private static void SaveNoteInfo()
        {
            var stream = new FileStream(_noteFilePath, FileMode.Create);
            var writer = new StreamWriter(stream);

            var note = new StringBuilder("{");

            foreach (PowerPoint.Slide slide in _objPres.Slides)
            {
                //writer.Write(slide.SlideIndex + "@");
                //读取每个幻灯片的备注文本  
                note.Append("{\"page\":\"" + slide.SlideIndex + "\",");

                foreach (PowerPoint.Shape nodeshape in slide.NotesPage.Shapes)
                {
                    if (nodeshape.TextFrame.HasText.Equals(MsoTriState.msoTrue))
                    {
                        //备注      
                        note.Append("\"note\":\"" + nodeshape.TextFrame.TextRange.Text + "\"");
                        //writer.Write(nodeshape.TextFrame.TextRange.Text);
                    }
                }

                note.Append("},");
                //writer.WriteLine();
            }

            note = note.Remove(note.Length - 1, 1).Append("}");

            writer.Write(note);

            writer.Close();
            stream.Close();

            writer.Dispose();
            stream.Dispose();
        }
    }
}

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.IO;
using System.Linq;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Threading.Tasks;
using System.Configuration;

namespace PPT2Vedio
{
    static class Program
    {
        // 处理文件夹临时路径
        private static String tempPath = ConfigurationManager.AppSettings["tempPath"];
        // 处理结果保存路径
        private static String resultPath = ConfigurationManager.AppSettings["resultPath"];
        // 视频分辨率
        private static String resolution = ConfigurationManager.AppSettings["resolution"];

        static void Main(string[] args)
        {
            // 监测文件夹路径
            var moniterPath = ConfigurationManager.AppSettings["moniterPath"];

            // 初始化文件夹监控线程
            var folderMoniterThread = InitFolderMoniterThread();
            folderMoniterThread.Start(moniterPath);
        }

        /// <summary>
        /// 文件夹监控线程
        /// </summary>
        private static Thread InitFolderMoniterThread()
        {
            var thread = new Thread(path =>
                {
                    while (true)
                    {
                        // 获取监控路径中的文件数量
                        String[] files = Directory.GetFiles(path.ToString(), "*.ppt*");

                        var builder = new StringBuilder();

                        foreach (var file in files)
                        {
                            builder.Append(file + "  ");
                        }

                        LogFactory.Info("获取文件数量:{0}  {1}", files.Length, builder);

                        // 先把文件转移
                        foreach (var file in files)
                        {
                            var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(file);

                            // 如果路径有中文，替换为guid
                            if (HasChinese(fileNameWithoutExtension))
                            {
                                fileNameWithoutExtension = Guid.NewGuid().ToString().Replace("-", "");
                            }

                            var path1 = Path.Combine(tempPath, fileNameWithoutExtension);

                            if (!Directory.Exists(path1))
                            {
                                Directory.CreateDirectory(path1);
                            }

                            LogFactory.Info("移动文件到新路径:{0}", path1);

                            var newPath = Path.Combine(path1, Path.GetFileName(file));

                            // 复制文件
                            File.Move(file, newPath);

                            LogFactory.Info("开始处理文件:{0}", file);
                            OperateFile(newPath);
                        }

                        // 3秒检查一次
                        Thread.Sleep(1000 * 3);
                    }
                });

            return thread;
        }

        /// <summary>
        /// 初始化处理文件线程
        /// </summary>
        /// <returns></returns>
        private static void OperateFile(String path)
        {
            var rootPath = Path.GetDirectoryName(path);

            // 启动转换Image程序
            CallProcess("ppt2image.exe", String.Format("-f {0} -o {1}", path, rootPath), false);

            // 杀死进程
            KillProcess("ppt2image");

            // 生成结果文件
            GernateResult(path);

            // 删除临时文件
            Directory.Delete(rootPath, true);
        }

        /// <summary>
        /// 生成结果文件
        /// </summary>
        /// <param name="path"></param>
        private static void GernateResult(String path)
        {
            var rootPath = Path.GetDirectoryName(path);

            var fileNameWithoutExtension = Path.GetFileNameWithoutExtension(path);

            if (!Directory.Exists(Path.Combine(resultPath, fileNameWithoutExtension)))
            {
                Directory.CreateDirectory(Path.Combine(resultPath, fileNameWithoutExtension));
            }

            // 复制备注结果文件
            File.Copy(Path.Combine(rootPath, fileNameWithoutExtension + "_note.txt"),
                      Path.Combine(resultPath, fileNameWithoutExtension, "note.txt"), true);


            // 复制文件
            File.Copy("ffmpeg.exe", Path.Combine(rootPath, "ffmpeg.exe"), true);


            var resultFilePath = Path.Combine(rootPath, fileNameWithoutExtension + "_result.txt");

            var list = GetFileToList(resultFilePath);

            List<String> durations = null;

            try
            {               
                // mp4临时文件
                var mp4TempFilePath = Path.Combine(rootPath, fileNameWithoutExtension + ".mp4");

                // 启动转换Vedio程序
                var resultStr = CallProcess(Path.Combine(rootPath, "ffmpeg.exe"),
                                            String.Format("-i \"{0}\" -r 45 -f mp4 -s {1} -b 600k -vcodec h264 {2}",
                                                            Path.Combine(rootPath, "%04d.jpg"),
                                                            resolution, mp4TempFilePath), true);

                durations = GetDurations(resultStr);

                File.Copy(mp4TempFilePath, Path.Combine(resultPath, fileNameWithoutExtension, fileNameWithoutExtension + ".mp4"), true);
            }
            catch (Exception ex)
            {
                LogFactory.Error("生成MP4文件异常:" + ex.Message);
            }

            // 复制图片文件
            var files = Directory.GetFiles(Path.Combine(rootPath, "images"));

            for (int index = 0; index < files.Length; index++)
            {
                try
                {
                    var file = files[index];
                    File.Move(file, Path.Combine(resultPath, fileNameWithoutExtension, (index + 1) + ".png"));
                }
                catch (Exception ex)
                {
                    LogFactory.Error("复制PPT图片报错:" + ex.Message);
                }

            }
            try
            {
                SaveResultFile(resultFilePath, list, durations);

                File.Copy(resultFilePath,
                    Path.Combine(resultPath, fileNameWithoutExtension, "result.txt"), true);
            }
            catch (Exception ex)
            {
                LogFactory.Error("复制结果文件报错:" + ex.Message);
            }
        }

        /// <summary>
        /// 改变文件名称
        /// </summary>
        /// <param name="startIndex"></param>
        /// <param name="endIndex"></param>
        /// <param name="files"></param>
        /// <param name="filePrefix"></param>
        private static void ChangeFileName(Int32 startIndex, Int32 endIndex, String[] files, String filePrefix)
        {
            var tempEndIndex = startIndex + 94;

            Int32 index = 1;
            foreach (var file in files)
            {
                var fileIndex = Int32.Parse(Path.GetFileNameWithoutExtension(file));

                if (fileIndex >= startIndex &&
                    fileIndex <= tempEndIndex)
                {
                    if (fileIndex <= endIndex)
                    {
                        // 如果在最后的索引范围内，直接复制
                        File.Copy(file, Path.Combine(Path.GetDirectoryName(file), filePrefix + "-" + index.ToString("000") + ".jpg"), true);
                    }
                    else
                    {
                        // 如果超出索引，复制最后一个文件
                        File.Copy(files[endIndex - 1], Path.Combine(Path.GetDirectoryName(file), filePrefix + "-" + index.ToString("000") + ".jpg"), true);
                    }


                    index++;
                }
                else
                {
                    index = 1;
                }
            }
        }

        /// <summary>
        /// 读取文件到集合中
        /// </summary>
        /// <param name="filePath"></param>
        /// <returns></returns>
        private static List<String> GetFileToList(String filePath)
        {
            var list = new List<String>();

            // 读取结果文件
            var stream = new FileStream(filePath, FileMode.Open);
            var reader = new StreamReader(stream);

            while (!reader.EndOfStream)
            {
                list.Add(reader.ReadLine());
            }

            reader.Close();
            stream.Close();

            reader.Dispose();
            stream.Dispose();

            return list;
        }

        /// <summary>
        /// 保存结果文件
        /// </summary>
        private static void SaveResultFile(String resultFilePath, IEnumerable<string> result, List<String> durations)
        {
            var stream = new FileStream(resultFilePath, FileMode.Create);
            var writer = new StreamWriter(stream);

            var temp = new StringBuilder("{");

            //var length = durations.Count > result.Count + 1 ? result.Count : durations.Count - 1;
            var duration = 3;
            foreach (var str in result)
            {
                var t = str.Split('-');
                var page = t[0];
                var animation = t[1];
                
                temp.Append("{\"page\":\"" + page + "\",\"animation\":\"" +
                            animation + "\",\"duration\":\"" + duration + "\"},");

                writer.Flush();
                stream.Flush();

                duration += 3;
            }

            temp = temp.Remove(temp.Length - 1, 1).Append("}");

            writer.Write(temp);

            writer.Close();
            stream.Close();

            writer.Dispose();
            stream.Dispose();
        }

        /// <summary>
        /// 保存结果文件
        /// </summary>
        private static List<String> GetDurations( String resultStr)
        {
            var reg = new Regex(@"time=(?<time>\d{2}:\d{2}:\d{2}.\d{2})");
            var matches = reg.Matches(resultStr);

            var list = new List<String>();

            for (int i = 0; i < matches.Count; i++)
            {
                Match match = matches[i];
                list.Add(match.Groups["time"].Value);
            }

            var tempList = new List<String>();
            // 合并结果
            for (int i = 0; i < list.Count - 1; i++)
            {
                var str1 = list[i];
                var str2 = list[i + 1];
            }

            return list;
        }

        /// <summary>
        /// 判断是否有中文
        /// </summary>
        /// <param name="words"></param>
        /// <returns></returns>
        public static bool HasChinese(string words)
        {
            string temp;
            for (int i = 0; i < words.Length; i++)
            {
                temp = words.Substring(i, 1);
                byte[] sarr = Encoding.GetEncoding("gb2312").GetBytes(temp);
                if (sarr.Length == 2)
                {
                    return true;
                }
            }
            return false;
        }

        /// <summary>
        /// 杀死进程
        /// </summary>
        /// <param name="processName"></param>
        private static void KillProcess(String processName)
        {
            foreach (var process in Process.GetProcesses())
            {
                if (process.ProcessName.ToLower().Contains(processName))
                {
                    process.Kill();
                }
            }
        }

        /// <summary>
        /// 启动程序
        /// </summary>
        /// <param name="fileName"></param>
        /// <param name="args"></param>
        /// <param name="isGetResults"> </param>
        private static String CallProcess(string fileName, string args, Boolean isGetResults)
        {
            var process = new Process();
            process.StartInfo.FileName = fileName;//设置运行的命令行文件
            process.StartInfo.Arguments = args;//设置命令参数
            process.StartInfo.CreateNoWindow = true;//不显示dos命令行窗口
            process.StartInfo.UseShellExecute = false;//是否指定操作系统外壳进程启动程序
            process.StartInfo.RedirectStandardOutput = isGetResults;
            process.StartInfo.RedirectStandardError = isGetResults;

            // 启动
            process.Start();

            var result = new StringBuilder();

            if (isGetResults)
            {
                process.OutputDataReceived += (s, e) => result.AppendLine(e.Data);
                process.ErrorDataReceived += (s, e) => result.AppendLine(e.Data);

                process.BeginErrorReadLine();
                process.BeginOutputReadLine();
            }


            // 等待完成
            process.WaitForExit();

            if (isGetResults)
            {
                process.CancelOutputRead();
                process.CancelErrorRead();

                return result.ToString();
            }
            else
            {
                return "";
            }
        }
    }
}

下载地址：百度网盘