private void resetClasses()
 {
     embeder   = null;
     extractor = null;
     GC.Collect(0, GCCollectionMode.Forced);
     GC.Collect(1, GCCollectionMode.Forced);
     GC.Collect(2, GCCollectionMode.Forced);
 }
        public async Task ReadAndEmbedVideoStream(string path, List <byte[]> data, IProgress <long> reportEmbededData, long embedSize, byte[] format, byte[] keystream, byte repeatcount, bool isRGB16)
        {
            getFileStamps(path);
            FileStream readVid = new FileStream(path, FileMode.Open, FileAccess.ReadWrite);

            using (readVid)
            {
                int    fID        = 4;
                long   seekOffset = 0;
                byte[] fourcc     = new byte[fID];
                readVid.Read(fourcc, 0, 4);
                int chunkSize = 0;
                int hops      = 0;
                embedsize2 = 0;
                if (embedSize % 2 != 0 && repeatcount != 0)
                {
                    embedsize2 = embedSize + 1;
                }
                else
                {
                    embedsize2 = embedSize;
                }
                embeder = new LSBEmbedderClass(data, isRGB16);
                int metaSize = 0;
                if (repeatcount == 0)
                {
                    metaSize = (cuttle.Length + 1 + 4 + format.Length + 4 + 16);
                }
                else
                {
                    metaSize = (cuttle.Length + 1 + 4 + format.Length + 4 + 2 + 1);
                }
                for (int i = 0; i < jOffsetList.Count; i++)
                {
                    readVid.Seek(jOffsetList[i], SeekOrigin.Begin);
                    readVid.Read(fourcc, 0, 4);
                    if (getEquivalentDecimal(fourcc) >= metaSize && !okCapJunkChunk)
                    {
                        okCapJunkChunk = true;
                        junkoffset     = jOffsetList[i] + 4;
                        break;
                    }
                }
                while (hops < vOffsetList.Count)
                {
                    seekOffset = vOffsetList[hops];
                    if (stopOperationFlag)
                    {
                        break;
                    }
                    if (embeder.getEmbeded() != embedsize2)
                    {
                        readVid.Seek(seekOffset, SeekOrigin.Begin);
                        readVid.Read(fourcc, 0, 4);
                        seekOffset += 4;
                        chunkSize   = getEquivalentDecimal(fourcc);
                        byte[] container = new byte[chunkSize];
                        readVid.Read(container, 0, chunkSize);
                        container = processChunk(container);
                        readVid.Seek(seekOffset, SeekOrigin.Begin);
                        readVid.Write(container, 0, chunkSize);
                        seekOffset += chunkSize;
                        reportEmbededData.Report(embeder.getEmbeded());
                    }
                    else
                    {
                        if (okCapJunkChunk)
                        {
                            byte flags = 0;
                            if (keystream.Length == 16)
                            {
                                flags = 1;
                            }

                            seekOffset = junkoffset - 4;
                            int pointer = 0;
                            readVid.Seek(seekOffset, SeekOrigin.Begin);
                            readVid.Read(fourcc, 0, 4);
                            chunkSize = getEquivalentDecimal(fourcc);
                            readVid.Write(cuttle, 0, cuttle.Length);
                            pointer += cuttle.Length;
                            readVid.WriteByte(flags);
                            pointer += 1;
                            readVid.Write(getEquivalentLittleEndian((long)format.Length), 0, 4);
                            pointer += 4;
                            readVid.Write(format, 0, format.Length);
                            pointer += format.Length;
                            readVid.Write(getEquivalentLittleEndian(embedSize), 0, 4);
                            pointer += 4;
                            readVid.Write(keystream, 0, keystream.Length);
                            pointer += keystream.Length;
                            if (flags == 0)
                            {
                                readVid.WriteByte(repeatcount);
                                pointer += 1;
                            }
                            while (pointer != chunkSize)
                            {
                                readVid.WriteByte(zero0x0);
                                pointer++;
                            }
                        }
                        else
                        {
                            byte flags = 0;
                            if (keystream.Length == 16)
                            {
                                flags = 1;
                            }
                            seekOffset = readVid.Length;
                            readVid.Seek(seekOffset, SeekOrigin.Begin);
                            readVid.Write(cuttle, 0, cuttle.Length);
                            readVid.WriteByte(flags);
                            readVid.Write(getEquivalentLittleEndian((long)format.Length), 0, 4);
                            readVid.Write(format, 0, format.Length);
                            readVid.Write(getEquivalentLittleEndian(embedSize), 0, 4);
                            readVid.Write(keystream, 0, keystream.Length);
                        }
                        break;
                    }
                    hops++;
                    if (hops % 2 == 0)
                    {
                        await Task.Delay(100);
                    }
                }
            }
            setFileStamps(path);
            readVid.Dispose();
            resetClasses();
        }