i2p/haiku-beta6
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Code style cleanup / honored 80 column line length limit. Modified FireWireDVAddOn to use BObjectList.

Browse Source 
Feel free to chime in if I missed any style violations.



git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@28000 a95241bf-73f2-0310-859d-f6bbb57e9c96
This commit is contained in:
Rene Gollent
2008-10-12 18:15:54 +00:00
parent 5222f12a32
commit d0da34f00f
7 changed files with 278 additions and 253 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/add-ons/media/media-add-ons/firewire_dv/FireWireCard.cpp
+45 -42
View File
@@ -6,6 +6,8 @@
* *
*/ */
#include "FireWireCard.h"
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
@@ -16,7 +18,6 @@
#include <stdint.h> #include <stdint.h>
#include <errno.h> #include <errno.h>
#include "FireWireCard.h"
#include "glue.h" #include "glue.h"
#define TAG (1<<6) #define TAG (1<<6)
@@ -79,11 +80,11 @@ struct mpeg_pldt {
#define MPEG_RBUFSIZE (MPEG_PSIZE * MPEG_NPACKET_R) #define MPEG_RBUFSIZE (MPEG_PSIZE * MPEG_NPACKET_R)
FireWireCard::FireWireCard(const char *path) FireWireCard::FireWireCard(const char* path)
: fInitStatus(B_OK) : fInitStatus(B_OK),
, fDev(-1) fDev(-1),
, fBuf(NULL) fBuf(NULL),
, fPad(NULL) fPad(NULL)
{ {
printf("FireWireCard opening %s\n", path); printf("FireWireCard opening %s\n", path);
@@ -111,7 +112,7 @@ FireWireCard::InitCheck()
ssize_t ssize_t
FireWireCard::Read(void **data) FireWireCard::Read(void** data)
{ {
if (fFormat == FMT_MPEGTS) if (fFormat == FMT_MPEGTS)
return MpegtsRead(data); return MpegtsRead(data);
@@ -121,7 +122,7 @@ FireWireCard::Read(void **data)
status_t status_t
FireWireCard::Extract(void *dest, void **src, ssize_t *sizeUsed) FireWireCard::Extract(void* dest, void** src, ssize_t* sizeUsed)
{ {
if (fFormat == FMT_MPEGTS) if (fFormat == FMT_MPEGTS)
return MpegtsExtract(dest, src, sizeUsed); return MpegtsExtract(dest, src, sizeUsed);
@@ -131,7 +132,7 @@ FireWireCard::Extract(void *dest, void **src, ssize_t *sizeUsed)
void void
FireWireCard::GetBufInfo(size_t *rbufsize, int *rcount) FireWireCard::GetBufInfo(size_t* rbufsize, int* rcount)
{ {
*rbufsize = fRbufSize; *rbufsize = fRbufSize;
*rcount = fRcount; *rcount = fRcount;
@@ -141,12 +142,13 @@ FireWireCard::GetBufInfo(size_t *rbufsize, int *rcount)
status_t status_t
FireWireCard::DetectRecvFn() FireWireCard::DetectRecvFn()
{ {
char *buf, ich = TAG | CHANNEL; char* buf;
char ich = TAG | CHANNEL;
struct fw_isochreq isoreq; struct fw_isochreq isoreq;
struct fw_isobufreq bufreq; struct fw_isobufreq bufreq;
int len; int len;
u_int32_t *ptr; u_int32_t* ptr;
struct ciphdr *ciph; struct ciphdr* ciph;
bufreq.rx.nchunk = 8; bufreq.rx.nchunk = 8;
bufreq.rx.npacket = 16; bufreq.rx.npacket = 16;
@@ -164,12 +166,12 @@ FireWireCard::DetectRecvFn()
if (ioctl(fDev, FW_SRSTREAM, &isoreq) < 0) if (ioctl(fDev, FW_SRSTREAM, &isoreq) < 0)
return errno; return errno;
buf = (char *)malloc(1024*16); buf = (char*)malloc(1024*16);
len = read(fDev, buf, 1024*16); len = read(fDev, buf, 1024*16);
if (len < 0) if (len < 0)
return errno; return errno;
ptr = (u_int32_t *) buf; ptr = (u_int32_t*) buf;
ciph = (struct ciphdr *)(ptr + 1); ciph = (struct ciphdr*)(ptr + 1);
switch(ciph->fmt) { switch(ciph->fmt) {
case CIP_FMT_DVCR: case CIP_FMT_DVCR:
@@ -197,7 +199,7 @@ FireWireCard::DetectRecvFn()
ssize_t ssize_t
FireWireCard::DvRead(void **buffer) FireWireCard::DvRead(void** buffer)
{ {
struct fw_isochreq isoreq; struct fw_isochreq isoreq;
struct fw_isobufreq bufreq; struct fw_isobufreq bufreq;
@@ -234,30 +236,30 @@ FireWireCard::DvRead(void **buffer)
status_t status_t
FireWireCard::DvExtract(void *dest, void **src, ssize_t *sizeUsed) FireWireCard::DvExtract(void* dest, void** src, ssize_t* sizeUsed)
{ {
struct dvdbc *dv; struct dvdbc* dv;
struct ciphdr *ciph; struct ciphdr* ciph;
struct fw_pkt *pkt; struct fw_pkt* pkt;
u_int32_t *ptr; u_int32_t* ptr;
int nblocks[] = {250 /* NTSC */, 300 /* PAL */}; int nblocks[] = {250 /* NTSC */, 300 /* PAL */};
int npad, k, m, system = -1, nb; int npad, k, m, system = -1, nb;
k = m = 0; k = m = 0;
ptr = (u_int32_t *) (*src); ptr = (u_int32_t*) (*src);
pkt = (struct fw_pkt *) ptr; pkt = (struct fw_pkt*) ptr;
ciph = (struct ciphdr *)(ptr + 1); /* skip iso header */ ciph = (struct ciphdr*)(ptr + 1); /* skip iso header */
if (ciph->fmt != CIP_FMT_DVCR) { if (ciph->fmt != CIP_FMT_DVCR) {
fprintf(stderr, "unknown format 0x%x", ciph->fmt); fprintf(stderr, "unknown format 0x%x", ciph->fmt);
return B_ERROR; return B_ERROR;
} }
ptr = (u_int32_t *) (ciph + 1); /* skip cip header */ ptr = (u_int32_t*) (ciph + 1); /* skip cip header */
if (pkt->mode.stream.len <= sizeof(struct ciphdr)) if (pkt->mode.stream.len <= sizeof(struct ciphdr))
/* no payload */ /* no payload */
return B_ERROR; return B_ERROR;
for (dv = (struct dvdbc *)ptr; for (dv = (struct dvdbc*)ptr;
(char *)dv < (char *)(ptr + ciph->len); (char*)dv < (char *)(ptr + ciph->len);
dv+=6) { dv+=6) {
if (dv->sct == DV_SCT_HEADER && dv->dseq == 0) { if (dv->sct == DV_SCT_HEADER && dv->dseq == 0) {
@@ -282,7 +284,7 @@ FireWireCard::DvExtract(void *dest, void **src, ssize_t *sizeUsed)
npad); npad);
npad *= DV_DSIZE; npad *= DV_DSIZE;
memcpy(dest, fPad, npad); memcpy(dest, fPad, npad);
dest = (char *)dest + npad; dest = (char*)dest + npad;
} }
#endif #endif
k++; k++;
@@ -297,16 +299,16 @@ FireWireCard::DvExtract(void *dest, void **src, ssize_t *sizeUsed)
continue; continue;
m++; m++;
memcpy(dest, dv, DV_DSIZE); memcpy(dest, dv, DV_DSIZE);
dest = (char *)dest + DV_DSIZE; dest = (char*)dest + DV_DSIZE;
} }
ptr = (u_int32_t *)dv; ptr = (u_int32_t*)dv;
*src = ptr; *src = ptr;
return B_OK; return B_OK;
} }
ssize_t ssize_t
FireWireCard::MpegtsRead(void **buffer) FireWireCard::MpegtsRead(void** buffer)
{ {
struct fw_isochreq isoreq; struct fw_isochreq isoreq;
struct fw_isobufreq bufreq; struct fw_isobufreq bufreq;
@@ -344,20 +346,20 @@ FireWireCard::MpegtsRead(void **buffer)
status_t status_t
FireWireCard::MpegtsExtract(void *dest, void **src, ssize_t *sizeUsed) FireWireCard::MpegtsExtract(void* dest, void** src, ssize_t* sizeUsed)
{ {
uint32_t *ptr; uint32_t* ptr;
struct fw_pkt *pkt; struct fw_pkt* pkt;
struct ciphdr *ciph; struct ciphdr* ciph;
struct mpeg_pldt *pld; struct mpeg_pldt* pld;
int pkt_size, startwr; int pkt_size, startwr;
ptr = (uint32_t *)(*src); ptr = (uint32_t *)(*src);
startwr = 0; startwr = 0;
pkt = (struct fw_pkt *) ptr; pkt = (struct fw_pkt*) ptr;
/* there is no CRC in the 1394 header */ /* there is no CRC in the 1394 header */
ciph = (struct ciphdr *)(ptr + 1); /* skip iso header */ ciph = (struct ciphdr*)(ptr + 1); /* skip iso header */
if (ciph->fmt != CIP_FMT_MPEG) { if (ciph->fmt != CIP_FMT_MPEG) {
fprintf(stderr, "unknown format 0x%x", ciph->fmt); fprintf(stderr, "unknown format 0x%x", ciph->fmt);
return B_ERROR; return B_ERROR;
@@ -367,7 +369,7 @@ FireWireCard::MpegtsExtract(void *dest, void **src, ssize_t *sizeUsed)
"fn=3 is supported)", ciph->fn); "fn=3 is supported)", ciph->fn);
return B_ERROR; return B_ERROR;
} }
ptr = (uint32_t *) (ciph + 1); /* skip cip header */ ptr = (uint32_t*) (ciph + 1); /* skip cip header */
if (pkt->mode.stream.len <= sizeof(struct ciphdr)) { if (pkt->mode.stream.len <= sizeof(struct ciphdr)) {
/* no payload */ /* no payload */
@@ -381,12 +383,12 @@ FireWireCard::MpegtsExtract(void *dest, void **src, ssize_t *sizeUsed)
startwr = 1; startwr = 1;
/* Read out all the MPEG TS data blocks from current packet */ /* Read out all the MPEG TS data blocks from current packet */
for (pld = (struct mpeg_pldt *)ptr; for (pld = (struct mpeg_pldt *)ptr;
(intptr_t)pld < (intptr_t)((char *)ptr + (intptr_t)pld < (intptr_t)((char*)ptr +
pkt->mode.stream.len - sizeof(struct ciphdr)); pkt->mode.stream.len - sizeof(struct ciphdr));
pld++) { pld++) {
if (startwr == 1) { if (startwr == 1) {
memcpy(dest, pld->payload, sizeof(pld->payload)); memcpy(dest, pld->payload, sizeof(pld->payload));
dest = (char *)dest + sizeof(pld->payload); dest = (char*)dest + sizeof(pld->payload);
} }
} }
@@ -394,7 +396,8 @@ next:
/* CRCs are removed from both header and trailer /* CRCs are removed from both header and trailer
so that only 4 bytes of 1394 header remains */ so that only 4 bytes of 1394 header remains */
pkt_size = pkt->mode.stream.len + 4; pkt_size = pkt->mode.stream.len + 4;
ptr = (uint32_t *)((intptr_t)pkt + pkt_size); ptr = (uint32_t*)((intptr_t)pkt + pkt_size);
*src = ptr; *src = ptr;
return B_OK; return B_OK;
} }
src/add-ons/media/media-add-ons/firewire_dv/FireWireCard.h
+19 -16
View File
@@ -9,35 +9,37 @@
#ifndef __FIREWIRE_CARD_H #ifndef __FIREWIRE_CARD_H
#define __FIREWIRE_CARD_H #define __FIREWIRE_CARD_H
#include <SupportDefs.h>
class FireWireCard class FireWireCard
{ {
public: public:
enum fmt_type { enum fmt_type {
FMT_MPEGTS = 0, FMT_MPEGTS = 0,
FMT_DV = 1, FMT_DV = 1,
}; };
FireWireCard(const char *path); FireWireCard(const char* path);
~FireWireCard(); ~FireWireCard();
status_t InitCheck(); status_t InitCheck();
status_t DetectRecvFn(); status_t DetectRecvFn();
ssize_t Read(void **buffer); ssize_t Read(void** buffer);
status_t Extract(void *dest, void **src, ssize_t *sizeUsed); status_t Extract(void* dest, void** src, ssize_t* sizeUsed);
void GetBufInfo(size_t *rbufsize, int *rcount); void GetBufInfo(size_t* rbufsize, int* rcount);
private: private:
ssize_t DvRead(void **buffer); ssize_t DvRead(void** buffer);
status_t DvExtract(void *dest, void **src, ssize_t *sizeUsed); status_t DvExtract(void* dest, void** src, ssize_t* sizeUsed);
ssize_t MpegtsRead(void **buffer); ssize_t MpegtsRead(void** buffer);
status_t MpegtsExtract(void *dest, void **src, ssize_t *sizeUsed); status_t MpegtsExtract(void* dest, void** src,
ssize_t* sizeUsed);
status_t fInitStatus; status_t fInitStatus;
int fDev; int fDev;
void *fBuf; void* fBuf;
void *fPad; void* fPad;
size_t fRbufSize; size_t fRbufSize;
int fRcount; int fRcount;
fmt_type fFormat; fmt_type fFormat;
@@ -45,3 +47,4 @@ private:
}; };
#endif #endif
src/add-ons/media/media-add-ons/firewire_dv/FireWireDVAddOn.cpp
+36 -21
View File
@@ -15,6 +15,7 @@
#include <stdio.h> #include <stdio.h>
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <Alert.h> #include <Alert.h>
#include <Directory.h> #include <Directory.h>
#include <Entry.h> #include <Entry.h>
@@ -24,35 +25,38 @@
struct device_info struct device_info
{ {
FireWireCard * card; FireWireCard* card;
char name[16]; char name[16];
media_format in_formats[1]; media_format in_formats[1];
media_format out_formats[1]; media_format out_formats[1];
flavor_info flavor; flavor_info flavor;
}; };
extern "C" BMediaAddOn * extern "C" BMediaAddOn*
make_media_addon(image_id id) make_media_addon(image_id id)
{ {
CALLED(); CALLED();
return new FireWireDVAddOn(id); return new FireWireDVAddOn(id);
} }
FireWireDVAddOn::FireWireDVAddOn(image_id id)
: BMediaAddOn(id)
{
CALLED();
ScanFolder("/dev/bus/fw");
}
FireWireDVAddOn::~FireWireDVAddOn() FireWireDVAddOn::~FireWireDVAddOn()
{ {
CALLED(); CALLED();
FreeDeviceList(); FreeDeviceList();
} }
FireWireDVAddOn::FireWireDVAddOn(image_id id)
: BMediaAddOn(id)
{
CALLED();
ScanFolder("/dev/bus/fw");
}
status_t status_t
FireWireDVAddOn::InitCheck(const char **out_failure_text) FireWireDVAddOn::InitCheck(const char** out_failure_text)
{ {
CALLED(); CALLED();
if (!fDeviceList.CountItems()) { if (!fDeviceList.CountItems()) {
@@ -62,6 +66,7 @@ FireWireDVAddOn::InitCheck(const char **out_failure_text)
return B_OK; return B_OK;
} }
int32 int32
FireWireDVAddOn::CountFlavors() FireWireDVAddOn::CountFlavors()
{ {
@@ -69,31 +74,36 @@ FireWireDVAddOn::CountFlavors()
return fDeviceList.CountItems(); return fDeviceList.CountItems();
} }
status_t status_t
FireWireDVAddOn::GetFlavorAt(int32 n, const flavor_info **out_info) FireWireDVAddOn::GetFlavorAt(int32 n, const flavor_info** out_info)
{ {
CALLED(); CALLED();
device_info *dev = (device_info *)fDeviceList.ItemAt(n); device_info* dev = fDeviceList.ItemAt(n);
if (!dev) if (!dev)
return B_ERROR; return B_ERROR;
*out_info = &dev->flavor; *out_info = &dev->flavor;
return B_OK; return B_OK;
} }
BMediaNode * BMediaNode *
FireWireDVAddOn::InstantiateNodeFor(const flavor_info *info, BMessage *config, status_t *out_error) FireWireDVAddOn::InstantiateNodeFor(const flavor_info* info, BMessage* config,
status_t* out_error)
{ {
CALLED(); CALLED();
device_info *dev = (device_info *)fDeviceList.ItemAt(info->internal_id); device_info* dev = fDeviceList.ItemAt(info->internal_id);
if (!dev || dev->flavor.internal_id != info->internal_id) { if (!dev || dev->flavor.internal_id != info->internal_id) {
*out_error = B_ERROR; *out_error = B_ERROR;
return NULL; return NULL;
} }
*out_error = B_OK; *out_error = B_OK;
return new FireWireDVNode(this, dev->name, dev->flavor.internal_id, dev->card); return new FireWireDVNode(this, dev->name, dev->flavor.internal_id,
dev->card);
} }
bool bool
FireWireDVAddOn::WantsAutoStart() FireWireDVAddOn::WantsAutoStart()
{ {
@@ -101,15 +111,18 @@ FireWireDVAddOn::WantsAutoStart()
return false; return false;
} }
status_t status_t
FireWireDVAddOn::AutoStart(int index, BMediaNode **outNode, int32 *outInternalID, bool *outHasMore) FireWireDVAddOn::AutoStart(int index, BMediaNode** outNode,
int32* outInternalID, bool* outHasMore)
{ {
CALLED(); CALLED();
return B_ERROR; return B_ERROR;
} }
void void
FireWireDVAddOn::ScanFolder(const char *path) FireWireDVAddOn::ScanFolder(const char* path)
{ {
CALLED(); CALLED();
BDirectory dir(path); BDirectory dir(path);
@@ -130,10 +143,11 @@ FireWireDVAddOn::ScanFolder(const char *path)
} }
} }
void void
FireWireDVAddOn::AddDevice(FireWireCard *card, const char *path) FireWireDVAddOn::AddDevice(FireWireCard* card, const char* path)
{ {
const char *fwnumber; const char* fwnumber;
// get card name, info and type // get card name, info and type
@@ -175,9 +189,10 @@ FireWireDVAddOn::AddDevice(FireWireCard *card, const char *path)
void void
FireWireDVAddOn::FreeDeviceList() FireWireDVAddOn::FreeDeviceList()
{ {
device_info *dev; device_info* dev;
while ((dev = (device_info *)fDeviceList.RemoveItem((int32)0))) { while ((dev = fDeviceList.RemoveItemAt(0L))) {
delete dev->card; delete dev->card;
delete dev; delete dev;
} }
} }
src/add-ons/media/media-add-ons/firewire_dv/FireWireDVAddOn.h
+13 -10
View File
@@ -12,34 +12,37 @@
#define _FIREWIRE_DV_ADDON_H_ #define _FIREWIRE_DV_ADDON_H_
#include <MediaAddOn.h> #include <MediaAddOn.h>
#include <ObjectList.h>
class FireWireCard; class FireWireCard;
struct device_info;
class FireWireDVAddOn : public BMediaAddOn class FireWireDVAddOn : public BMediaAddOn
{ {
public: public:
FireWireDVAddOn(image_id id); FireWireDVAddOn(image_id id);
~FireWireDVAddOn(); ~FireWireDVAddOn();
status_t InitCheck(const char **out_failure_text); status_t InitCheck(const char** out_failure_text);
int32 CountFlavors(); int32 CountFlavors();
status_t GetFlavorAt(int32 n, const flavor_info **out_info); status_t GetFlavorAt(int32 n, const flavor_info** out_info);
BMediaNode *InstantiateNodeFor(const flavor_info *info, BMessage *config, status_t *out_error); BMediaNode* InstantiateNodeFor(const flavor_info* info,
BMessage* config, status_t* out_error);
bool WantsAutoStart(); bool WantsAutoStart();
status_t AutoStart(int index, BMediaNode **outNode, int32 *outInternalID, bool *outHasMore); status_t AutoStart(int index, BMediaNode** outNode,
int32* outInternalID, bool* outHasMore);
protected: protected:
void ScanFolder(const char *path); void ScanFolder(const char* path);
void AddDevice(FireWireCard* card, const char* path);
void AddDevice(FireWireCard *card, const char *path);
void FreeDeviceList(); void FreeDeviceList();
protected: protected:
BList fDeviceList; BObjectList<device_info> fDeviceList;
}; };
#endif #endif
src/add-ons/media/media-add-ons/firewire_dv/FireWireDVNode.cpp
+71 -74
View File
@@ -8,6 +8,8 @@
* Copyright (c) 2004-2007 Marcus Overhagen <[email protected]> * Copyright (c) 2004-2007 Marcus Overhagen <[email protected]>
*/ */
#include "FireWireDVNode.h"
#include <fcntl.h> #include <fcntl.h>
#include <malloc.h> #include <malloc.h>
#include <math.h> #include <math.h>
@@ -17,18 +19,17 @@
#include <sys/uio.h> #include <sys/uio.h>
#include <unistd.h> #include <unistd.h>
#include <MediaRoster.h> #include <Autolock.h>
#include <Buffer.h> #include <Buffer.h>
#include <BufferGroup.h> #include <BufferGroup.h>
#include <ParameterWeb.h>
#include <TimeSource.h>
#include <String.h>
#include <Autolock.h>
#include <Debug.h> #include <Debug.h>
#include <Directory.h> #include <Directory.h>
#include <Entry.h> #include <Entry.h>
#include <MediaRoster.h>
#include <ParameterWeb.h>
#include <Path.h> #include <Path.h>
#include <TimeSource.h>
#include <String.h>
#include "FireWireDVNode.h" #include "FireWireDVNode.h"
#include "FireWireCard.h" #include "FireWireCard.h"
@@ -42,7 +43,7 @@
#ifdef TRACE #ifdef TRACE
# undef TRACE # undef TRACE
#endif #endif
#define TRACE_FIREWIRE_NODE //#define TRACE_FIREWIRE_NODE
#ifdef TRACE_FIREWIRE_NODE #ifdef TRACE_FIREWIRE_NODE
# define TRACE(x...) printf(x) # define TRACE(x...) printf(x)
#else #else
@@ -53,20 +54,19 @@
#define M_REFRESH_PARAMETER_WEB (BTimedEventQueue::B_USER_EVENT + 1) #define M_REFRESH_PARAMETER_WEB (BTimedEventQueue::B_USER_EVENT + 1)
FireWireDVNode::FireWireDVNode( FireWireDVNode::FireWireDVNode(BMediaAddOn* addon, const char* name,
BMediaAddOn *addon, const char *name, int32 internal_id, FireWireCard* card)
int32 internal_id, FireWireCard *card) : BMediaNode(name),
: BMediaNode(name) BBufferProducer(B_MEDIA_ENCODED_VIDEO),
, BBufferProducer(B_MEDIA_ENCODED_VIDEO) BControllable(),
, BControllable() BMediaEventLooper(),
, BMediaEventLooper() fOutputEnabledEncVideo(false),
, fOutputEnabledEncVideo(false) fCard(card),
, fCard(card) fCaptureThreadsActive(false),
, fCaptureThreadsActive(false) fThreadIdCardReader(-1),
, fThreadIdCardReader(-1) fTerminateThreads(false),
, fTerminateThreads(false) fBufferGroupEncVideo(0),
, fBufferGroupEncVideo(0) fCaptureActive(false)
, fCaptureActive(false)
{ {
CALLED(); CALLED();
@@ -92,10 +92,8 @@ FireWireDVNode::~FireWireDVNode()
/* BMediaNode */ /* BMediaNode */
BMediaAddOn*
FireWireDVNode::AddOn(int32* internal_id) const
BMediaAddOn *
FireWireDVNode::AddOn(int32 *internal_id) const
{ {
if (internal_id) if (internal_id)
*internal_id = fInternalID; *internal_id = fInternalID;
@@ -104,7 +102,7 @@ FireWireDVNode::AddOn(int32 *internal_id) const
status_t status_t
FireWireDVNode::HandleMessage(int32 message, const void *data, size_t size) FireWireDVNode::HandleMessage(int32 message, const void* data, size_t size)
{ {
return B_ERROR; return B_ERROR;
} }
@@ -119,7 +117,7 @@ FireWireDVNode::Preroll()
void void
FireWireDVNode::SetTimeSource(BTimeSource *time_source) FireWireDVNode::SetTimeSource(BTimeSource* time_source)
{ {
CALLED(); CALLED();
} }
@@ -134,8 +132,6 @@ FireWireDVNode::SetRunMode(run_mode mode)
/* BMediaEventLooper */ /* BMediaEventLooper */
void void
FireWireDVNode::NodeRegistered() FireWireDVNode::NodeRegistered()
{ {
@@ -156,8 +152,8 @@ FireWireDVNode::NodeRegistered()
void void
FireWireDVNode::HandleEvent(const media_timed_event *event, FireWireDVNode::HandleEvent(const media_timed_event* event,
bigtime_t lateness, bool realTimeEvent) bigtime_t lateness, bool realTimeEvent)
{ {
switch(event->type) switch(event->type)
@@ -188,12 +184,10 @@ FireWireDVNode::HandleEvent(const media_timed_event *event,
/* BBufferProducer */ /* BBufferProducer */
status_t status_t
FireWireDVNode::FormatChangeRequested(const media_source &source, FireWireDVNode::FormatChangeRequested(const media_source& source,
const media_destination &destination, media_format *io_format, const media_destination& destination, media_format* io_format,
int32 *_deprecated_) int32* _deprecated_)
{ {
CALLED(); CALLED();
@@ -203,7 +197,7 @@ FireWireDVNode::FormatChangeRequested(const media_source &source,
status_t status_t
FireWireDVNode::GetNextOutput(int32 *cookie, media_output *out_output) FireWireDVNode::GetNextOutput(int32* cookie, media_output* out_output)
{ {
CALLED(); CALLED();
@@ -227,7 +221,7 @@ FireWireDVNode::DisposeOutputCookie(int32 cookie)
status_t status_t
FireWireDVNode::SetBufferGroup(const media_source &source, BBufferGroup *group) FireWireDVNode::SetBufferGroup(const media_source& source, BBufferGroup* group)
{ {
CALLED(); CALLED();
return B_ERROR; return B_ERROR;
@@ -235,9 +229,9 @@ FireWireDVNode::SetBufferGroup(const media_source &source, BBufferGroup *group)
status_t status_t
FireWireDVNode::VideoClippingChanged(const media_source &for_source, FireWireDVNode::VideoClippingChanged(const media_source& for_source,
int16 num_shorts, int16 *clip_data, int16 num_shorts, int16* clip_data,
const media_video_display_info &display, int32 *_deprecated_) const media_video_display_info& display, int32* _deprecated_)
{ {
CALLED(); CALLED();
return B_ERROR; return B_ERROR;
@@ -245,7 +239,7 @@ FireWireDVNode::VideoClippingChanged(const media_source &for_source,
status_t status_t
FireWireDVNode::GetLatency(bigtime_t *out_latency) FireWireDVNode::GetLatency(bigtime_t* out_latency)
{ {
CALLED(); CALLED();
@@ -256,7 +250,7 @@ FireWireDVNode::GetLatency(bigtime_t *out_latency)
status_t status_t
FireWireDVNode::FormatSuggestionRequested( FireWireDVNode::FormatSuggestionRequested(
media_type type, int32 quality, media_format *format) media_type type, int32 quality, media_format* format)
{ {
CALLED(); CALLED();
@@ -280,7 +274,8 @@ FireWireDVNode::FormatSuggestionRequested(
status_t status_t
FireWireDVNode::FormatProposal(const media_source &source, media_format *format) FireWireDVNode::FormatProposal(const media_source& source,
media_format* format)
{ {
CALLED(); CALLED();
/* The connection process: /* The connection process:
@@ -320,9 +315,9 @@ FireWireDVNode::FormatProposal(const media_source &source, media_format *format)
status_t status_t
FireWireDVNode::PrepareToConnect(const media_source &source, FireWireDVNode::PrepareToConnect(const media_source& source,
const media_destination &destination, media_format *format, const media_destination& destination, media_format* format,
media_source *out_source, char *out_name) media_source* out_source, char* out_name)
{ {
/* The connection process: /* The connection process:
* BBufferProducer::FormatProposal * BBufferProducer::FormatProposal
@@ -372,9 +367,9 @@ FireWireDVNode::PrepareToConnect(const media_source &source,
void void
FireWireDVNode::Connect(status_t error, const media_source &source, FireWireDVNode::Connect(status_t error, const media_source& source,
const media_destination &destination, const media_format &format, const media_destination& destination, const media_format& format,
char *io_name) char* io_name)
{ {
/* The connection process: /* The connection process:
* BBufferProducer::FormatProposal * BBufferProducer::FormatProposal
@@ -417,7 +412,7 @@ FireWireDVNode::Connect(status_t error, const media_source &source,
void void
FireWireDVNode::Disconnect(const media_source &source, FireWireDVNode::Disconnect(const media_source &source,
const media_destination &destination) const media_destination& destination)
{ {
CALLED(); CALLED();
@@ -428,16 +423,16 @@ FireWireDVNode::Disconnect(const media_source &source,
void void
FireWireDVNode::LateNoticeReceived(const media_source &source, FireWireDVNode::LateNoticeReceived(const media_source& source,
bigtime_t how_much, bigtime_t performance_time) bigtime_t how_much, bigtime_t performance_time)
{ {
TRACE("FireWireDVNode::LateNoticeReceived %Ld late at %Ld\n", how_much, performance_time); TRACE("FireWireDVNode::LateNoticeReceived %Ld late at %Ld\n", how_much, performance_time);
} }
void void
FireWireDVNode::EnableOutput(const media_source &source, bool enabled, FireWireDVNode::EnableOutput(const media_source& source, bool enabled,
int32 *_deprecated_) int32* _deprecated_)
{ {
CALLED(); CALLED();
fOutputEnabledEncVideo = enabled; fOutputEnabledEncVideo = enabled;
@@ -445,9 +440,9 @@ FireWireDVNode::EnableOutput(const media_source &source, bool enabled,
void void
FireWireDVNode::AdditionalBufferRequested(const media_source &source, FireWireDVNode::AdditionalBufferRequested(const media_source& source,
media_buffer_id prev_buffer, bigtime_t prev_time, media_buffer_id prev_buffer, bigtime_t prev_time,
const media_seek_tag *prev_tag) const media_seek_tag* prev_tag)
{ {
CALLED(); CALLED();
// we don't support offline mode // we don't support offline mode
@@ -456,8 +451,6 @@ FireWireDVNode::AdditionalBufferRequested(const media_source &source,
/* FireWireDVNode */ /* FireWireDVNode */
void void
FireWireDVNode::HandleTimeWarp(bigtime_t performance_time) FireWireDVNode::HandleTimeWarp(bigtime_t performance_time)
{ {
@@ -559,7 +552,7 @@ FireWireDVNode::StopCaptureThreads()
int32 int32
FireWireDVNode::_card_reader_thread_(void *arg) FireWireDVNode::_card_reader_thread_(void* arg)
{ {
static_cast<FireWireDVNode *>(arg)->card_reader_thread(); static_cast<FireWireDVNode *>(arg)->card_reader_thread();
return 0; return 0;
@@ -585,10 +578,10 @@ FireWireDVNode::card_reader_thread()
continue; continue;
} }
end = (char *)data + sizeUsed; end = (char*)data + sizeUsed;
while (data < end) { while (data < end) {
BBuffer *buf = fBufferGroupEncVideo->RequestBuffer(rbufsize, 10000); BBuffer* buf = fBufferGroupEncVideo->RequestBuffer(rbufsize, 10000);
if (!buf) { if (!buf) {
TRACE("OutVideo: request buffer timout\n"); TRACE("OutVideo: request buffer timout\n");
continue; continue;
@@ -608,12 +601,12 @@ FireWireDVNode::card_reader_thread()
//what should the start_time be? //what should the start_time be?
hdr->start_time = TimeSource()->PerformanceTimeFor(system_time()); hdr->start_time = TimeSource()->PerformanceTimeFor(system_time());
lock.Lock(); fLock.Lock();
if (B_OK != SendBuffer(buf, fOutputEncVideo.destination)) { if (B_OK != SendBuffer(buf, fOutputEncVideo.destination)) {
TRACE("OutVideo: sending buffer failed\n"); TRACE("OutVideo: sending buffer failed\n");
buf->Recycle(); buf->Recycle();
} }
lock.Unlock(); fLock.Unlock();
} }
} }
@@ -631,7 +624,7 @@ FireWireDVNode::RefreshParameterWeb()
void void
FireWireDVNode::SetAboutInfo(BParameterGroup *about) FireWireDVNode::SetAboutInfo(BParameterGroup* about)
{ {
//May need more useful infomation? //May need more useful infomation?
about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "FireWireDV media_addon info:", B_GENERIC); about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "FireWireDV media_addon info:", B_GENERIC);
@@ -648,17 +641,17 @@ BParameterWeb *
FireWireDVNode::CreateParameterWeb() FireWireDVNode::CreateParameterWeb()
{ {
/* Set up the parameter web */ /* Set up the parameter web */
BParameterWeb *web = new BParameterWeb(); BParameterWeb* web = new BParameterWeb();
BString name; BString name;
name << Name(); name << Name();
BParameterGroup *main = web->MakeGroup(name.String()); BParameterGroup* main = web->MakeGroup(name.String());
if (!fCaptureActive) { if (!fCaptureActive) {
BParameterGroup *info = main->MakeGroup("Info"); BParameterGroup* info = main->MakeGroup("Info");
info->MakeNullParameter(0, B_MEDIA_NO_TYPE, info->Name(), B_GENERIC); info->MakeNullParameter(0, B_MEDIA_NO_TYPE, info->Name(), B_GENERIC);
BParameterGroup *about = main->MakeGroup("About"); BParameterGroup* about = main->MakeGroup("About");
about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC); about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC);
SetAboutInfo(about); SetAboutInfo(about);
info->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Node is stopped", B_GENERIC); info->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Node is stopped", B_GENERIC);
@@ -666,7 +659,7 @@ FireWireDVNode::CreateParameterWeb()
return web; return web;
} }
BParameterGroup *about = main->MakeGroup("About"); BParameterGroup* about = main->MakeGroup("About");
about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC); about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC);
SetAboutInfo(about); SetAboutInfo(about);
@@ -675,7 +668,8 @@ FireWireDVNode::CreateParameterWeb()
status_t status_t
FireWireDVNode::GetParameterValue(int32 id, bigtime_t *last_change, void *value, size_t *size) FireWireDVNode::GetParameterValue(int32 id, bigtime_t* last_change,
void* value, size_t* size)
{ {
TRACE("FireWireDVNode::GetParameterValue, id 0x%lx\n", id); TRACE("FireWireDVNode::GetParameterValue, id 0x%lx\n", id);
//do we need Parameter for firewire dv? //do we need Parameter for firewire dv?
@@ -684,9 +678,12 @@ FireWireDVNode::GetParameterValue(int32 id, bigtime_t *last_change, void *value,
void void
FireWireDVNode::SetParameterValue(int32 id, bigtime_t when, const void *value, size_t size) FireWireDVNode::SetParameterValue(int32 id, bigtime_t when, const void* value,
size_t size)
{ {
TRACE("FireWireDVNode::SetParameterValue, id 0x%lx, size %ld, value 0x%lx\n", id, size, *(const int32 *)value); TRACE("FireWireDVNode::SetParameterValue, id 0x%lx, size %ld, "
"value 0x%lx\n", id, size, *(const int32*)value);
//do we need parameter for firewire dv? //do we need parameter for firewire dv?
TRACE("FireWireDVNode::SetParameterValue finished\n"); TRACE("FireWireDVNode::SetParameterValue finished\n");
} }
src/add-ons/media/media-add-ons/firewire_dv/FireWireDVNode.h
+91 -89
View File
@@ -27,119 +27,121 @@ class BParameterGroup;
class FireWireDVNode : public virtual BBufferProducer, class FireWireDVNode : public virtual BBufferProducer,
public virtual BControllable, public virtual BMediaEventLooper { public virtual BControllable, public virtual BMediaEventLooper {
public: public:
FireWireDVNode(BMediaAddOn *addon, FireWireDVNode(BMediaAddOn *addon,
const char *name, int32 internal_id, FireWireCard *card); const char *name, int32 internal_id,
virtual ~FireWireDVNode(); FireWireCard *card);
virtual ~FireWireDVNode();
virtual status_t InitCheck() const { return fInitStatus; }
virtual status_t InitCheck() const { return fInitStatus; }
/* BMediaNode */ /* BMediaNode */
public: public:
virtual BMediaAddOn *AddOn(int32 * internal_id) const; virtual BMediaAddOn *AddOn(int32 * internal_id) const;
virtual status_t HandleMessage(int32 message, const void *data, virtual status_t HandleMessage(int32 message, const void *data,
size_t size); size_t size);
protected: protected:
virtual void Preroll(); virtual void Preroll();
virtual void SetTimeSource(BTimeSource * time_source); virtual void SetTimeSource(BTimeSource * time_source);
virtual void SetRunMode(run_mode mode); virtual void SetRunMode(run_mode mode);
/* BMediaEventLooper */ /* BMediaEventLooper */
protected: protected:
virtual void NodeRegistered(); virtual void NodeRegistered();
virtual void HandleEvent(const media_timed_event *event,
virtual void HandleEvent(const media_timed_event *event, bigtime_t lateness,
bigtime_t lateness, bool realTimeEvent = false); bool realTimeEvent = false);
/* BBufferProducer */ /* BBufferProducer */
protected: protected:
virtual status_t FormatSuggestionRequested(media_type type, int32 quality, virtual status_t FormatSuggestionRequested(media_type type,
media_format * format); int32 quality, media_format* format);
virtual status_t FormatProposal(const media_source &source, virtual status_t FormatProposal(const media_source &source,
media_format *format); media_format* format);
virtual status_t FormatChangeRequested(const media_source &source, virtual status_t FormatChangeRequested(
const media_destination &destination, const media_source &source,
media_format *io_format, int32 *_deprecated_); const media_destination &destination,
virtual status_t GetNextOutput(int32 * cookie, media_output * out_output); media_format* io_format,
virtual status_t DisposeOutputCookie(int32 cookie); int32* _deprecated_);
virtual status_t SetBufferGroup(const media_source &for_source, virtual status_t GetNextOutput(int32* cookie,
BBufferGroup * group); media_output* out_output);
virtual status_t VideoClippingChanged(const media_source &for_source, virtual status_t DisposeOutputCookie(int32 cookie);
int16 num_shorts, int16 *clip_data, virtual status_t SetBufferGroup(const media_source& for_source,
const media_video_display_info &display, BBufferGroup* group);
int32 * _deprecated_); virtual status_t VideoClippingChanged(
virtual status_t GetLatency(bigtime_t * out_latency); const media_source& for_source,
virtual status_t PrepareToConnect(const media_source &what, int16 num_shorts, int16* clip_data,
const media_destination &where, const media_video_display_info &display,
media_format *format, int32* _deprecated_);
media_source *out_source, char *out_name); virtual status_t GetLatency(bigtime_t* out_latency);
virtual void Connect(status_t error, const media_source &source, virtual status_t PrepareToConnect(const media_source& what,
const media_destination &destination, const media_destination& where,
const media_format & format, char *io_name); media_format* format,
virtual void Disconnect(const media_source & what, media_source* out_source,
const media_destination & where); char* out_name);
virtual void LateNoticeReceived(const media_source & what, virtual void Connect(status_t error,
bigtime_t how_much, bigtime_t performance_time); const media_source& source,
virtual void EnableOutput(const media_source & what, bool enabled, const media_destination& destination,
int32 * _deprecated_); const media_format& format,
virtual void AdditionalBufferRequested(const media_source & source, char* io_name);
media_buffer_id prev_buffer, bigtime_t prev_time, virtual void Disconnect(const media_source& what,
const media_seek_tag * prev_tag); const media_destination& where);
virtual void LateNoticeReceived(const media_source& what,
bigtime_t how_much,
bigtime_t performance_time);
virtual void EnableOutput(const media_source& what,
bool enabled, int32* _deprecated_);
virtual void AdditionalBufferRequested(
const media_source& source,
media_buffer_id prev_buffer,
bigtime_t prev_time,
const media_seek_tag* prev_tag);
/* BControllable */ /* BControllable */
protected: protected:
virtual status_t GetParameterValue(int32 id, bigtime_t *last_change, virtual status_t GetParameterValue(int32 id,
void *value, size_t *size); bigtime_t* last_change, void* value,
virtual void SetParameterValue(int32 id, bigtime_t when, size_t* size);
const void *value, size_t size); virtual void SetParameterValue(int32 id, bigtime_t when,
const void* value, size_t size);
/* state */ /* state */
private: private:
void HandleStart(bigtime_t performance_time); void HandleStart(bigtime_t performance_time);
void HandleStop(); void HandleStop();
void HandleTimeWarp(bigtime_t performance_time); void HandleTimeWarp(bigtime_t performance_time);
void HandleSeek(bigtime_t performance_time); void HandleSeek(bigtime_t performance_time);
BParameterWeb * CreateParameterWeb(); BParameterWeb* CreateParameterWeb();
void SetAboutInfo(BParameterGroup *about); void SetAboutInfo(BParameterGroup *about);
void RefreshParameterWeb(); void RefreshParameterWeb();
status_t StartCapture(); status_t StartCapture();
status_t StopCapture(); status_t StopCapture();
status_t StartCaptureThreads(); status_t StartCaptureThreads();
status_t StopCaptureThreads(); status_t StopCaptureThreads();
static int32 _card_reader_thread_(void *arg); static int32 _card_reader_thread_(void *arg);
void card_reader_thread(); void card_reader_thread();
status_t fInitStatus; status_t fInitStatus;
int32 fInternalID;
int32 fInternalID; BMediaAddOn* fAddOn;
BMediaAddOn *fAddOn; bool fOutputEnabledEncVideo;
media_output fOutputEncVideo;
bool fOutputEnabledEncVideo; media_format fDefaultFormatEncVideo;
FireWireCard* fCard;
media_output fOutputEncVideo; bool fCaptureThreadsActive;
thread_id fThreadIdCardReader;
media_format fDefaultFormatEncVideo; volatile bool fTerminateThreads;
BBufferGroup* fBufferGroupEncVideo;
FireWireCard * fCard; BParameterWeb* fWeb;
bool fCaptureActive;
bool fCaptureThreadsActive; BLocker fLock;
thread_id fThreadIdCardReader;
volatile bool fTerminateThreads;
BBufferGroup * fBufferGroupEncVideo;
BParameterWeb * fWeb;
bool fCaptureActive;
BLocker lock;
}; };
#endif // __FIREWIRE_DV_NODE_H #endif // __FIREWIRE_DV_NODE_H
src/add-ons/media/media-add-ons/firewire_dv/Jamfile
+3 -1
View File
@@ -1,8 +1,10 @@
SubDir HAIKU_TOP src add-ons media media-add-ons firewire_dv ; SubDir HAIKU_TOP src add-ons media media-add-ons firewire_dv ;
UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ; UseHeaders [ FDirName $(HAIKU_TOP) headers compatibility bsd ] : true ;
UsePrivateHeaders media ;
UsePrivateHeaders firewire ; UsePrivateHeaders firewire ;
UsePrivateHeaders media ;
UsePrivateHeaders shared ;
Addon firewire_dv.media_addon : Addon firewire_dv.media_addon :
FireWireCard.cpp FireWireCard.cpp