added unmodified mmbtools

1 files changed, 280 insertions, 0 deletions

diff --git a/src/Dmb.cpp b/src/Dmb.cpp
new file mode 100644
index 0000000..95742d0
--- /dev/null
+++ b/src/Dmb.cpp
@@ -0,0 +1,280 @@
+/*
+   Copyright (C) 2005, 2006, 2007, 2008, 2009 Her Majesty the Queen in Right
+   of Canada (Communications Research Center Canada)
+   */
+/*
+   This file is part of CRC-DabMux.
+
+   CRC-DabMux is free software: you can redistribute it and/or modify
+   it under the terms of the GNU General Public License as
+   published by the Free Software Foundation, either version 3 of the
+   License, or (at your option) any later version.
+
+   CRC-DabMux is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+   GNU General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with CRC-DabMux.  If not, see <http://www.gnu.org/licenses/>.
+   */
+
+#include "Dmb.h"
+
+#include <string.h>
+
+
+#ifdef _WIN32
+#   define bzero(a, b) memset((a), 0, (b))
+#endif // _WIN32
+
+
+DmbStats::DmbStats()
+{
+    reset();
+}
+
+            
+void DmbStats::reset()
+{
+    memset(this, 0, sizeof(*this));
+}
+
+
+Dmb::Dmb(bool reverse) :
+interleaver(12, 17),
+encoder(204, 188)
+{
+    buffer = NULL;
+    bufferSize = 0;
+    setReverse(reverse);
+}
+
+
+Dmb::~Dmb()
+{
+    if (buffer != NULL) {
+        delete[] buffer;
+    }
+}
+
+
+void Dmb::setReverse(bool state)
+{
+    reverse = state;
+    reset();
+
+    interleaver.setReverse(state);
+    encoder.setReverse(state);
+    stats.reset();
+}
+
+
+void Dmb::reset()
+{
+    bufferOffset = 0;
+    bufferLength = 0;
+    inputOffset = 0;
+    outputOffset = 0;
+//    padding = 0;
+}
+
+
+#include <stdio.h>
+int Dmb::encode(
+        void* dataIn,
+        unsigned long sizeIn,
+        void* dataOut,
+        unsigned long sizeOut
+        )
+{
+    int ret = 0;
+    char* input = reinterpret_cast<char*>(dataIn);
+    char* output = reinterpret_cast<char*>(dataOut);
+
+    if (bufferSize < sizeIn + 204) {
+        if (buffer != NULL) {
+            delete[] buffer;
+        }
+        unsigned char* oldBuffer = buffer;
+        bufferSize = sizeIn + 204;
+        buffer = new unsigned char[bufferSize];
+        memcpy(buffer, oldBuffer, bufferLength);
+    }
+
+    if (reverse) {
+//        fprintf(stderr, "*** Decode ***\n");
+//        fprintf(stderr, " sizeIn: %i\n", sizeIn);
+//        fprintf(stderr, " inputOffset: %i\n", inputOffset);
+//        fprintf(stderr, " bufferLength: %i\n", bufferLength);
+//        fprintf(stderr, " bufferOffset: %i\n", bufferOffset);
+//        fprintf(stderr, " outputOffset: %i\n", outputOffset);
+
+        if (inputOffset == 0) {
+            ++stats.dmbFrame;
+            stats.rcvBytes += sizeIn;
+        }
+
+        memcpy(&buffer[bufferLength], &input[inputOffset],
+                sizeIn - inputOffset);
+        interleaver.encode(&buffer[bufferLength], sizeIn - inputOffset);
+        bufferLength += sizeIn - inputOffset;
+        inputOffset += sizeIn - inputOffset;
+        while (bufferLength - bufferOffset >= 204) {
+            if (buffer[bufferOffset] != 0x47) {
+                int offset = sync(&buffer[bufferOffset],
+                        bufferLength - bufferOffset);
+                if (offset == 0) {
+                    bufferLength = 0;
+                    bufferOffset = 0;
+                } else {
+                    bufferOffset += offset;
+                }
+            } else {
+                if (outputOffset + 188 <= sizeOut) { // If enough place
+                    int error = encoder.encode(&buffer[bufferOffset], 204);
+                    if (error != -1) {
+//                    if (true) {
+                        if (error > 0) {
+                            stats.corBytes += error;
+                        }
+                        memcpy(&output[outputOffset], &buffer[bufferOffset],
+                                188);
+                        if (((buffer[bufferOffset + 1] & 0x1f) == 0x1f) &&
+                                (buffer[bufferOffset + 2] == 0xff)) {
+                            stats.nulBytes += 188;
+                        } else {
+                            ret += 188;
+                            stats.sndBytes += 188;
+                            outputOffset += 188;
+                        }
+                        bufferOffset += 204;
+                        ++stats.mpgFrame;
+                    } else {
+//                        interleaver.reset();
+//                        padding = 0;
+//                        bufferLength = 0;
+//                        inputOffset = 0;
+//                        stats.errBytes += 188;
+                        bufferOffset += 12;
+                        stats.errBytes += 12;
+                        ++stats.synFrame;
+                        int offset = sync (&buffer[bufferOffset],
+                                bufferLength - bufferOffset);
+                        if (offset == 0) {
+                            stats.errBytes += bufferLength - bufferOffset;
+                            bufferOffset = 0;
+                            bufferLength = 0;
+                        } else {
+                            stats.errBytes += offset;
+                            bufferOffset += offset;
+                        }
+                    }
+                } else {
+                    outputOffset = 0;
+                    goto ENCODE_END;
+                }
+            }
+        }
+        memmove(buffer, &buffer[bufferOffset], bufferLength - bufferOffset);
+        bufferLength -= bufferOffset;
+        bufferOffset = 0;
+        if (ret == 0) {
+            inputOffset = 0;
+        } else {
+            outputOffset = 0;
+        }
+//        fprintf(stderr, " ret: %i\n\n", ret);
+    } else {
+        if (sizeIn == 0) {
+            bzero(&output[outputOffset], sizeOut - outputOffset);
+            interleaver.encode(&output[outputOffset], sizeOut - outputOffset);
+            outputOffset = 0;
+            ++stats.dmbFrame;
+            stats.sndBytes += sizeOut;
+            goto ENCODE_END;
+        }
+
+        if (bufferLength == 204) {     // If buffer is not empty
+            // If there's more data in buffer than place in output
+            if (204 - bufferOffset > sizeOut - outputOffset) {
+                memcpy(&output[outputOffset], &buffer[bufferOffset],
+                        sizeOut - outputOffset);
+                bufferOffset += sizeOut - outputOffset;
+                outputOffset = 0;
+                ++stats.dmbFrame;
+                stats.sndBytes += sizeOut;
+                goto ENCODE_END;
+            }
+            memcpy(&output[outputOffset], &buffer[bufferOffset],
+                    204 - bufferOffset);
+            outputOffset += 204 - bufferOffset;
+            bufferOffset = 0;
+            bufferLength = 0;
+        }
+
+        while (true) {
+            // If there's not enought input data
+            if (sizeIn - inputOffset < 188 - bufferLength) {
+                memcpy(&buffer[bufferLength], &input[inputOffset],
+                        sizeIn - inputOffset);
+                bufferLength += sizeIn - inputOffset;
+                ret = outputOffset;
+                inputOffset = 0;
+                goto ENCODE_END;
+            }
+            if (buffer[bufferLength] == 0x47) {
+                ++stats.mpgFrame;
+            }
+//            fprintf(stderr, "++mpg: %i, sizeIn: %i, inputOffset: %i\n",
+//            stats.mpgFrame, sizeIn, inputOffset);
+            stats.rcvBytes += 188;
+
+            memcpy(&buffer[bufferLength], &input[inputOffset],
+                    188 - bufferLength);
+            inputOffset += 188 - bufferLength;
+
+            encoder.encode(buffer, 188);
+            interleaver.encode(buffer, 204);
+            bufferLength = 204;
+
+            if (sizeOut - outputOffset < 204) {
+                memcpy(&output[outputOffset], buffer, sizeOut - outputOffset);
+                bufferOffset += sizeOut - outputOffset;
+                outputOffset = 0;
+                ++stats.dmbFrame;
+                stats.sndBytes += sizeOut;
+                goto ENCODE_END;
+            }
+            memcpy(&output[outputOffset], buffer, 204);
+            outputOffset += 204;
+            bufferLength = 0;
+        }
+    }
+
+ENCODE_END:
+    return ret;
+}
+
+
+int Dmb::sync(void* dataIn, unsigned long sizeIn)
+{
+    char* input = reinterpret_cast<char*>(dataIn);
+    char* sync = input;
+    unsigned long size = sizeIn;
+
+    while (sync != NULL) {
+        sync = (char*)memchr(sync, 0x47, size);
+        if (sync != NULL) {
+            int offset = sync - input;
+            if (offset % 12 != 0) {
+                offset = ((offset / 12) * 12) + 12;
+                sync = &input[offset];
+                size = sizeIn - offset;
+            } else {
+                return offset;
+            }
+        }
+    }
+    return 0;
+}