Ticket #2970: media.diff

headers/os/media/MediaEncoder.h

@@ -8 +8 @@
 
 #include <MediaFormats.h>
 
+namespace BPrivate {
+    class Encoder;
+}
+
+namespace BPrivate {
+    namespace media {
+        class Encoder;
+        class EncoderPlugin;
+    }
+}
 
 class BMediaEncoder {
 public:
@@ -65 +75 @@
             BMediaEncoder&      operator=(const BMediaEncoder& other);
 
 private:
+    status_t                    _AttachToEncoder();
+
     static  status_t            write_chunk(void* classPtr,
                                     const void* buffer, size_t size,
                                     media_encode_info* info);
@@ -73 +85 @@
             void                ReleaseEncoder();
 
             uint32              _reserved_was_fEncoderMgr;
-            uint32              _reserved_was_fEncoder;
-
+//          uint32              _reserved_was_fEncoder;
+            BPrivate::media::Encoder        *fEncoder;
+            
             int32               fEncoderID;
             bool                fFormatValid;
             bool                fEncoderStarted;

src/kits/media/MediaEncoder.cpp

@@ -1 @@
-/***********************************************************************
- * AUTHOR: Marcus Overhagen
- *   FILE: MediaEncoder.cpp
- *  DESCR: 
- ***********************************************************************/
+/*
+ * Copyright 2004-2007, Marcus Overhagen. All rights reserved.
+ * Copyright 2010, Oleg Krysenkov, beos344@mail.ru.
+ *
+ * Distributed under the terms of the MIT License.
+ */
+
+/*TO DO SetTo, SetFormat, Enode Class*/
 #include <MediaEncoder.h>
+#include <EncoderPlugin.h>
+#include <PluginManager.h>
+#include <new>
 #include "debug.h"
 
-
 /*************************************************************
  * public BMediaEncoder
  *************************************************************/
 
 BMediaEncoder::BMediaEncoder()
+    :   fEncoder(NULL),
+        fInitStatus(B_NO_INIT)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::BMediaEncoder 1 enter\n");
 }
 
 
 BMediaEncoder::BMediaEncoder(const media_format *output_format)
+    :   fEncoder(NULL),
+        fInitStatus(B_NO_INIT)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::BMediaEncoder 2 enter\n");
+    SetTo(output_format);
 }
 
 
 BMediaEncoder::BMediaEncoder(const media_codec_info *mci)
+    :   fEncoder(NULL),
+        fInitStatus(B_NO_INIT)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::BMediaEncoder 3 enter\n");
+    SetTo(mci);
 }
 
 
 /* virtual */
 BMediaEncoder::~BMediaEncoder()
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::~BMediaEncoder enter\n");
+    gPluginManager.DestroyEncoder(fEncoder);
+    fEncoder = NULL;
 }
 
 
 status_t 
 BMediaEncoder::InitCheck() const
 {
-    UNIMPLEMENTED();
-
-    return B_OK;
+    TRACE("BMediaEncoder::InitCheck enter\n");
+    return fInitStatus;
 }
 
+
 status_t 
 BMediaEncoder::SetTo(const media_format *output_format)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::SetTo 1 enter\n");
+    status_t err;
+    media_codec_info codec_info;
+    int32 cookie = 0;
+
+    while ((err = get_next_encoder(&cookie, NULL, NULL, output_format, 
+            &codec_info, NULL, NULL)) == B_OK) {
+/*         printf(" %s / %s (%d)\n", mci.pretty_name, mci.short_name,
+                  mci.id);*/
+    }   
+    if (err != B_OK)
+        return err;
+    
+    return SetTo(&codec_info);
+
+/* My code to test.
+    gPluginManager.DestroyEncoder(fEncoder);
+    fEncoder = NULL;
+
+    status_t err = gPluginManager.CreateEncoder(&fEncoder, *output_format);
+    if (err < B_OK)
+        goto fail;
+
+    err = _AttachToEncoder();
+    if (err < B_OK)
+        goto fail;
+
+//  err = SetFormat(NULL, output_format); //Look at MediaDecoder
+//  if (err < B_OK)
+//      goto fail;
+
+    fInitStatus = B_OK;
     return B_OK;
+
+fail:
+    gPluginManager.DestroyEncoder(fEncoder);
+    fEncoder = NULL;
+    fInitStatus = B_NO_INIT;
+    return err;*/
 }
 
+
 status_t 
 BMediaEncoder::SetTo(const media_codec_info *mci)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaEncoder::SetTo 2 enter\n");
+    gPluginManager.DestroyEncoder(fEncoder);
+    fEncoder = NULL;
+
+    //flags are not used but needed some how.
+    status_t err = gPluginManager.CreateEncoder(&fEncoder, mci, 0);
+    if (err < B_OK)
+        goto fail;
+
+    err = _AttachToEncoder();
+    if (err < B_OK)
+        goto fail;
+
+    fInitStatus = B_OK;
     return B_OK;
+
+fail:
+    gPluginManager.DestroyEncoder(fEncoder);
+    fEncoder = NULL;
+    fInitStatus = B_NO_INIT;
+    return err;
 }
 
 
@@ -64 +136 @@
                          media_format *output_format,
                          media_file_format *mfi)
 {
+    TRACE("BMediaEncoder::SetFormat enter\n");
+//  SetTo(output_format);
     UNIMPLEMENTED();
     return B_OK;
+/*  if (!fEncoder)
+        return B_NO_INIT;
+
+    media_format format = *in_format;
+    return fEncoder->Setup(&format, in_info, in_size);*/
 }
 
+
 status_t 
 BMediaEncoder::Encode(const void *buffer, 
                       int64 frame_count,
                       media_encode_info *info)
 {
-    UNIMPLEMENTED();
-    return B_OK;
+    TRACE("BMediaEncoder::Encode enter\n");
+    if (!fEncoder)
+        return B_NO_INIT;
+
+    return fEncoder->Encode(buffer, frame_count, info);
 }
 
 
 status_t 
 BMediaEncoder::GetEncodeParameters(encode_parameters *parameters) const
 {
-    UNIMPLEMENTED();
-    return B_OK;
+    TRACE("BMediaEncoder::GetEncodeParameters enter\n");
+    if (fEncoder == NULL)
+        return B_NO_INIT;
+    else 
+        return fEncoder->GetEncodeParameters(parameters);
 }
 
 
 status_t 
 BMediaEncoder::SetEncodeParameters(encode_parameters *parameters)
 {
-    UNIMPLEMENTED();
-    return B_OK;
+    TRACE("BMediaEncoder::SetEncodeParameters enter\n");
+    if (fEncoder == NULL)
+        return B_NO_INIT;
+    else 
+        return fEncoder->SetEncodeParameters(parameters);
 }
 
 
@@ -101 +190 @@
 /* virtual */ status_t 
 BMediaEncoder::AddTrackInfo(uint32 code, const char *data, size_t size)
 {
-    UNIMPLEMENTED();
-    return B_OK;
+    TRACE("BMediaEncoder::AddTrackInfo enter\n");
+    if (fEncoder == NULL)
+        return B_NO_INIT;
+    else 
+        return fEncoder->AddTrackInfo(code, data, size);
 }
 
 
@@ -122 +214 @@
                            size_t chunk_len, 
                            media_encode_info *info)
 {
-    UNIMPLEMENTED();
-    return B_OK;
+    TRACE("BMediaEncoder::write_chunk enter\n");
+    if (fEncoder == NULL)
+        return B_NO_INIT;
+        
+    return fEncoder->WriteChunk(chunk_data, chunk_len, info);
 }
 
 
 void
 BMediaEncoder::Init()
 {
+    TRACE("BMediaEncoder::Init enter\n");
     UNIMPLEMENTED();
 }
 
@@ -137 +233 @@
 void 
 BMediaEncoder::ReleaseEncoder()
 {
+    TRACE("BMediaEncoder::ReleaseEncoder enter\n");
     UNIMPLEMENTED();
 }
 
+
+status_t
+BMediaEncoder::_AttachToEncoder()
+{
+    class MediaEncoderChunkWriter : public ChunkWriter {
+    private:
+        BMediaEncoder* fEncoder;
+    public:
+        MediaEncoderChunkWriter(BMediaEncoder* encoder) 
+        {
+            fEncoder = encoder;
+        }
+        virtual status_t WriteChunk(const void* chunkBuffer, size_t chunkSize,
+                                    media_encode_info* encodeInfo) 
+        {
+            return fEncoder->WriteChunk(chunkBuffer, chunkSize, encodeInfo);
+        }
+    }* writer = new(std::nothrow) MediaEncoderChunkWriter(this);
+    
+    if (!writer)
+        return B_NO_MEMORY;
+    
+    fEncoder->SetChunkWriter(writer);
+    return B_OK;
+}
+
+
 status_t BMediaEncoder::_Reserved_BMediaEncoder_0(int32 arg, ...) { return B_ERROR; }
 status_t BMediaEncoder::_Reserved_BMediaEncoder_1(int32 arg, ...) { return B_ERROR; }
 status_t BMediaEncoder::_Reserved_BMediaEncoder_2(int32 arg, ...) { return B_ERROR; }
@@ -162 +286 @@
  *************************************************************/
 
 BMediaBufferEncoder::BMediaBufferEncoder()
+    :   BMediaEncoder(),
+        fBuffer(NULL)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaBufferEncoder::BMediaBufferEncoder enter\n");
 }
 
 
 BMediaBufferEncoder::BMediaBufferEncoder(const media_format *output_format)
+    :   BMediaEncoder(output_format), 
+        fBuffer(NULL)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaBufferEncoder::BMediaBufferEncoder 1 enter\n");
 }
 
 
 BMediaBufferEncoder::BMediaBufferEncoder(const media_codec_info *mci)
+    :   BMediaEncoder(mci), 
+        fBuffer(NULL)
 {
-    UNIMPLEMENTED();
+    TRACE("BMediaBufferEncoder::BMediaBufferEncoder 2 enter\n");
 }
 
 
@@ -186 +316 @@
                                     int64 frame_count,
                                     media_encode_info *info)
 {
-    UNIMPLEMENTED();
-
-    return B_ERROR;
+    TRACE("BMediaBufferEncoder::EncodeToBuffer enter\n");
+    status_t error;
+    fBuffer = output_buffer;
+    fBufferSize = *output_size;
+    error = Encode(input_buffer, frame_count, info);
+    if (fBuffer) {
+        fBuffer = NULL;
+        *output_size = 0;
+    } else {
+        *output_size = fBufferSize;
+    }
+    return error;
 }
 
 
@@ -201 +340 @@
                                 size_t chunk_len,
                                 media_encode_info *info)
 {
-    UNIMPLEMENTED();
-
-    return B_ERROR;
+    TRACE("BMediaBufferEncoder::WriteChunk enter\n");
+    if (fBuffer == NULL)
+        return B_ENTRY_NOT_FOUND;
+    
+    if ((ssize_t)chunk_len < 0)
+        return B_ERROR;
+    
+    if (chunk_len > (size_t)fBufferSize) {
+        memcpy(fBuffer, chunk_data, fBufferSize);
+        fBuffer = NULL;
+        return B_DEVICE_FULL;
+    }
+    
+    memcpy(fBuffer, chunk_data, chunk_len);
+    fBufferSize = chunk_len;
+    fBuffer = NULL;
+    return B_NO_ERROR;
 }